Documentation

Index

Constants

View Source
const (
	KindPage = "page"

	KindHome         = "home"
	KindSection      = "section"
	KindTaxonomy     = "taxonomy"
	KindTaxonomyTerm = "taxonomyTerm"
)

Variables

View Source
var (
	// CommitHash contains the current Git revision. Use make to build to make
	// sure this gets set.
	CommitHash string

	// BuildDate contains the date of the current build.
	BuildDate string
)
View Source
var ErrHasDraftAndPublished = errors.New("both draft and published parameters were found in page's frontmatter")
View Source
var ErrNoConfigFile = errors.New("Unable to locate Config file. Perhaps you need to create a new site.\n       Run `hugo help new` for details.\n")

Functions

func LoadConfig

func LoadConfig(d ConfigSourceDescriptor, doWithConfig ...func(cfg config.Provider) error) (*viper.Viper, []string, error)

    LoadConfig loads Hugo configuration into a new Viper and then adds a set of defaults.

    func LoadConfigDefault

    func LoadConfigDefault(fs afero.Fs) (*viper.Viper, error)

      LoadConfigDefault is a convenience method to load the default "config.toml" config.

      Types

      type Author

      type Author struct {
      	GivenName   string
      	FamilyName  string
      	DisplayName string
      	Thumbnail   string
      	Image       string
      	ShortBio    string
      	LongBio     string
      	Email       string
      	Social      AuthorSocial
      }

        Author contains details about the author of a page.

        type AuthorList

        type AuthorList map[string]Author

          AuthorList is a list of all authors and their metadata.

          type AuthorSocial

          type AuthorSocial map[string]string

            AuthorSocial is a place to put social details per author. These are the standard keys that themes will expect to have available, but can be expanded to any others on a per site basis - website - github - facebook - twitter - googleplus - pinterest - instagram - youtube - linkedin - skype

            type BuildCfg

            type BuildCfg struct {
            	// Reset site state before build. Use to force full rebuilds.
            	ResetState bool
            	// Re-creates the sites from configuration before a build.
            	// This is needed if new languages are added.
            	CreateSitesFromConfig bool
            	// Skip rendering. Useful for testing.
            	SkipRender bool
            
            	// Recently visited URLs. This is used for partial re-rendering.
            	RecentlyVisited map[string]bool
            	// contains filtered or unexported fields
            }

              BuildCfg holds build options used to, as an example, skip the render step.

              type ConfigSourceDescriptor

              type ConfigSourceDescriptor struct {
              	Fs afero.Fs
              
              	// Full path to the config file to use, i.e. /my/project/config.toml
              	Filename string
              
              	// The path to the directory to look for configuration. Is used if Filename is not
              	// set.
              	Path string
              
              	// The project's working dir. Is used to look for additional theme config.
              	WorkingDir string
              }

                ConfigSourceDescriptor describes where to find the config (e.g. config.toml etc.).

                type HugoInfo

                type HugoInfo struct {
                	Version    helpers.HugoVersionString
                	Generator  template.HTML
                	CommitHash string
                	BuildDate  string
                }

                  HugoInfo contains information about the current Hugo environment

                  type HugoSites

                  type HugoSites struct {
                  	Sites []*Site
                  
                  	*deps.Deps
                  
                  	// Keeps track of bundle directories and symlinks to enable partial rebuilding.
                  	ContentChanges *contentChangeMap
                  	// contains filtered or unexported fields
                  }

                    HugoSites represents the sites to build. Each site represents a language.

                    func NewHugoSites

                    func NewHugoSites(cfg deps.DepsCfg) (*HugoSites, error)

                      NewHugoSites creates HugoSites from the given config.

                      func (*HugoSites) Build

                      func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error

                        Build builds all sites. If filesystem events are provided, this is considered to be a potential partial rebuild.

                        func (*HugoSites) GC

                        func (h *HugoSites) GC() (int, error)

                          GC requires a build first.

                          func (*HugoSites) GetContentPage

                          func (h *HugoSites) GetContentPage(filename string) *Page

                            GetContentPage finds a Page with content given the absolute filename. Returns nil if none found.

                            func (*HugoSites) IsMultihost

                            func (h *HugoSites) IsMultihost() bool

                            func (*HugoSites) NumLogErrors

                            func (h *HugoSites) NumLogErrors() int

                            func (*HugoSites) Pages

                            func (h *HugoSites) Pages() Pages

                              Pages returns all pages for all sites.

                              func (*HugoSites) PrintProcessingStats

                              func (h *HugoSites) PrintProcessingStats(w io.Writer)

                              type Image

                              type Image struct {
                              
                              	// The URL of the image. In some cases, the image URL may not be on the
                              	// same domain as your main site. This is fine, as long as both domains
                              	// are verified in Webmaster Tools. If, for example, you use a
                              	// content delivery network (CDN) to host your images, make sure that the
                              	// hosting site is verified in Webmaster Tools OR that you submit your
                              	// sitemap using robots.txt. In addition, make sure that your robots.txt
                              	// file doesn’t disallow the crawling of any content you want indexed.
                              	URL     string
                              	Title   string
                              	Caption string
                              	AltText string
                              
                              	// The geographic location of the image. For example,
                              	// <image:geo_location>Limerick, Ireland</image:geo_location>.
                              	GeoLocation string
                              
                              	// A URL to the license of the image.
                              	License string
                              }

                                An Image contains metadata for images + image sitemaps https://support.google.com/webmasters/answer/178636?hl=en

                                type Menu []*MenuEntry

                                  Menu is a collection of menu entries.

                                  func (m Menu) ByName() Menu

                                    ByName sorts the menu by the name defined in the menu configuration.

                                    func (m Menu) ByWeight() Menu

                                      ByWeight sorts the menu by the weight defined in the menu configuration.

                                      func (m Menu) Limit(n int) Menu

                                        Limit limits the returned menu to n entries.

                                        func (m Menu) Reverse() Menu

                                          Reverse reverses the order of the menu entries.

                                          func (m Menu) Sort() Menu

                                            Sort sorts the menu by weight, name and then by identifier.

                                            type MenuEntry struct {
                                            	URL        string
                                            	Page       *Page
                                            	Name       string
                                            	Menu       string
                                            	Identifier string
                                            
                                            	Pre      template.HTML
                                            	Post     template.HTML
                                            	Weight   int
                                            	Parent   string
                                            	Children Menu
                                            	// contains filtered or unexported fields
                                            }

                                              MenuEntry represents a menu item defined in either Page front matter or in the site config.

                                              func (m *MenuEntry) HasChildren() bool

                                                HasChildren returns whether this menu item has any children.

                                                func (m *MenuEntry) IsEqual(inme *MenuEntry) bool

                                                  IsEqual returns whether the two menu entries represents the same menu entry.

                                                  func (m *MenuEntry) IsSameResource(inme *MenuEntry) bool

                                                    IsSameResource returns whether the two menu entries points to the same resource (URL).

                                                    func (m *MenuEntry) KeyName() string

                                                      KeyName returns the key used to identify this menu entry.

                                                      func (m *MenuEntry) Title() string
                                                      type Menus map[string]*Menu

                                                        Menus is a dictionary of menus.

                                                        type Multilingual

                                                        type Multilingual struct {
                                                        	Languages langs.Languages
                                                        
                                                        	DefaultLang *langs.Language
                                                        	// contains filtered or unexported fields
                                                        }

                                                          Multilingual manages the all languages used in a multilingual site.

                                                          func (*Multilingual) Language

                                                          func (ml *Multilingual) Language(lang string) *langs.Language

                                                            Language returns the Language associated with the given string.

                                                            type OrderedTaxonomy

                                                            type OrderedTaxonomy []OrderedTaxonomyEntry

                                                              OrderedTaxonomy is another representation of an Taxonomy using an array rather than a map. Important because you can't order a map.

                                                              func (OrderedTaxonomy) Reverse

                                                              func (t OrderedTaxonomy) Reverse() OrderedTaxonomy

                                                                Reverse reverses the order of the entries in this taxonomy.

                                                                type OrderedTaxonomyEntry

                                                                type OrderedTaxonomyEntry struct {
                                                                	Name          string
                                                                	WeightedPages WeightedPages
                                                                }

                                                                  OrderedTaxonomyEntry is similar to an element of a Taxonomy, but with the key embedded (as name) e.g: {Name: Technology, WeightedPages: Taxonomyedpages}

                                                                  func (OrderedTaxonomyEntry) Count

                                                                  func (ie OrderedTaxonomyEntry) Count() int

                                                                    Count returns the count the pages in this taxonomy.

                                                                    func (OrderedTaxonomyEntry) Pages

                                                                    func (ie OrderedTaxonomyEntry) Pages() Pages

                                                                      Pages returns the Pages for this taxonomy.

                                                                      func (OrderedTaxonomyEntry) Term

                                                                      func (ie OrderedTaxonomyEntry) Term() string

                                                                        Term returns the name given to this taxonomy.

                                                                        type OutputFormat

                                                                        type OutputFormat struct {
                                                                        	// Rel constains a value that can be used to construct a rel link.
                                                                        	// This is value is fetched from the output format definition.
                                                                        	// Note that for pages with only one output format,
                                                                        	// this method will always return "canonical".
                                                                        	// As an example, the AMP output format will, by default, return "amphtml".
                                                                        	//
                                                                        	// See:
                                                                        	// https://www.ampproject.org/docs/guides/deploy/discovery
                                                                        	//
                                                                        	// Most other output formats will have "alternate" as value for this.
                                                                        	Rel string
                                                                        	// contains filtered or unexported fields
                                                                        }

                                                                          OutputFormat links to a representation of a resource.

                                                                          func (OutputFormat) MediaType

                                                                          func (o OutputFormat) MediaType() media.Type

                                                                            MediaType returns this OutputFormat's MediaType (MIME type).

                                                                            func (OutputFormat) Name

                                                                            func (o OutputFormat) Name() string

                                                                              Name returns this OutputFormat's name, i.e. HTML, AMP, JSON etc.

                                                                              func (o *OutputFormat) Permalink() string

                                                                                Permalink returns the absolute permalink to this output format.

                                                                                func (o *OutputFormat) RelPermalink() string

                                                                                  RelPermalink returns the relative permalink to this output format.

                                                                                  type OutputFormats

                                                                                  type OutputFormats []*OutputFormat

                                                                                    OutputFormats holds a list of the relevant output formats for a given resource.

                                                                                    func (OutputFormats) Get

                                                                                    func (o OutputFormats) Get(name string) *OutputFormat

                                                                                      Get gets a OutputFormat given its name, i.e. json, html etc. It returns nil if not found.

                                                                                      type Page

                                                                                      type Page struct {
                                                                                      
                                                                                      	// Kind is the discriminator that identifies the different page types
                                                                                      	// in the different page collections. This can, as an example, be used
                                                                                      	// to to filter regular pages, find sections etc.
                                                                                      	// Kind will, for the pages available to the templates, be one of:
                                                                                      	// page, home, section, taxonomy and taxonomyTerm.
                                                                                      	// It is of string type to make it easy to reason about in
                                                                                      	// the templates.
                                                                                      	Kind string
                                                                                      
                                                                                      	// Since Hugo 0.18 we got rid of the Node type. So now all pages are ...
                                                                                      	// pages (regular pages, home page, sections etc.).
                                                                                      	// Sections etc. will have child pages. These were earlier placed in .Data.Pages,
                                                                                      	// but can now be more intuitively also be fetched directly from .Pages.
                                                                                      	// This collection will be nil for regular pages.
                                                                                      	Pages Pages
                                                                                      
                                                                                      	// Since Hugo 0.32, a Page can have resources such as images and CSS associated
                                                                                      	// with itself. The resource will typically be placed relative to the Page,
                                                                                      	// but templates should use the links (Permalink and RelPermalink)
                                                                                      	// provided by the Resource object.
                                                                                      	Resources resource.Resources
                                                                                      
                                                                                      	TableOfContents template.HTML
                                                                                      
                                                                                      	Aliases []string
                                                                                      
                                                                                      	Images []Image
                                                                                      	Videos []Video
                                                                                      
                                                                                      	Draft  bool
                                                                                      	Status string
                                                                                      
                                                                                      	// PageMeta contains page stats such as word count etc.
                                                                                      	PageMeta
                                                                                      
                                                                                      	// Markup contains the markup type for the content.
                                                                                      	Markup string
                                                                                      
                                                                                      	Layout string
                                                                                      
                                                                                      	Source
                                                                                      
                                                                                      	Position `json:"-"`
                                                                                      
                                                                                      	GitInfo *gitmap.GitInfo
                                                                                      
                                                                                      	Site *SiteInfo `json:"-"`
                                                                                      
                                                                                      	Description string
                                                                                      	Keywords    []string
                                                                                      
                                                                                      	pagemeta.PageDates
                                                                                      
                                                                                      	Sitemap Sitemap
                                                                                      	pagemeta.URLPath
                                                                                      	// contains filtered or unexported fields
                                                                                      }

                                                                                      func (*Page) AllTranslations

                                                                                      func (p *Page) AllTranslations() Pages

                                                                                        AllTranslations returns all translations, including the current Page.

                                                                                        func (*Page) AlternativeOutputFormats

                                                                                        func (p *Page) AlternativeOutputFormats() (OutputFormats, error)

                                                                                          AlternativeOutputFormats is only available on the top level rendering entry point, and not inside range loops on the Page collections. This method is just here to inform users of that restriction.

                                                                                          func (*Page) Author

                                                                                          func (p *Page) Author() Author

                                                                                          func (*Page) Authors

                                                                                          func (p *Page) Authors() AuthorList

                                                                                          func (*Page) BundleType

                                                                                          func (p *Page) BundleType() string

                                                                                            BundleType returns the bundle type: "leaf", "branch" or an empty string if it is none. See https://gohugo.io/content-management/page-bundles/

                                                                                            func (*Page) Content

                                                                                            func (p *Page) Content() (interface{}, error)

                                                                                            func (*Page) CurrentSection

                                                                                            func (p *Page) CurrentSection() *Page

                                                                                              CurrentSection returns the page's current section or the page itself if home or a section. Note that this will return nil for pages that is not regular, home or section pages.

                                                                                              func (*Page) Data

                                                                                              func (p *Page) Data() interface{}

                                                                                              func (*Page) Eq

                                                                                              func (p *Page) Eq(other interface{}) bool

                                                                                                Eq returns whether the current page equals the given page. Note that this is more accurate than doing `{{ if eq $page $otherPage }}` since a Page can be embedded in another type.

                                                                                                func (*Page) FirstSection

                                                                                                func (p *Page) FirstSection() *Page

                                                                                                  FirstSection returns the section on level 1 below home, e.g. "/docs". For the home page, this will return itself.

                                                                                                  func (*Page) FullFilePath

                                                                                                  func (p *Page) FullFilePath() string

                                                                                                  func (*Page) FuzzyWordCount

                                                                                                  func (p *Page) FuzzyWordCount() int

                                                                                                  func (*Page) GetPage

                                                                                                  func (p *Page) GetPage(ref string) (*Page, error)

                                                                                                    GetPage looks up a page for the given ref.

                                                                                                    {{ with .GetPage "blog" }}{{ .Title }}{{ end }}
                                                                                                    

                                                                                                    This will return nil when no page could be found, and will return an error if the ref is ambiguous.

                                                                                                    func (*Page) GetParam

                                                                                                    func (p *Page) GetParam(key string) interface{}

                                                                                                    func (*Page) HasMenuCurrent

                                                                                                    func (p *Page) HasMenuCurrent(menuID string, me *MenuEntry) bool

                                                                                                    func (*Page) HasShortcode

                                                                                                    func (p *Page) HasShortcode(name string) bool

                                                                                                      HasShortcode return whether the page has a shortcode with the given name. This method is mainly motivated with the Hugo Docs site's need for a list of pages with the `todo` shortcode in it.

                                                                                                      func (*Page) Hugo

                                                                                                      func (p *Page) Hugo() *HugoInfo

                                                                                                      func (*Page) InSection

                                                                                                      func (p *Page) InSection(other interface{}) (bool, error)

                                                                                                        InSection returns whether the given page is in the current section. Note that this will always return false for pages that are not either regular, home or section pages.

                                                                                                        func (*Page) IsAncestor

                                                                                                        func (p *Page) IsAncestor(other interface{}) (bool, error)

                                                                                                          IsAncestor returns whether the current page is an ancestor of the given page. Note that this method is not relevant for taxonomy lists and taxonomy terms pages.

                                                                                                          func (*Page) IsDescendant

                                                                                                          func (p *Page) IsDescendant(other interface{}) (bool, error)

                                                                                                            IsDescendant returns whether the current page is a descendant of the given page. Note that this method is not relevant for taxonomy lists and taxonomy terms pages.

                                                                                                            func (*Page) IsDraft

                                                                                                            func (p *Page) IsDraft() bool

                                                                                                            func (*Page) IsExpired

                                                                                                            func (p *Page) IsExpired() bool

                                                                                                            func (*Page) IsFuture

                                                                                                            func (p *Page) IsFuture() bool

                                                                                                            func (*Page) IsHome

                                                                                                            func (p *Page) IsHome() bool

                                                                                                              IsHome returns whether this is the home page.

                                                                                                              func (*Page) IsMenuCurrent

                                                                                                              func (p *Page) IsMenuCurrent(menuID string, inme *MenuEntry) bool

                                                                                                              func (*Page) IsNode

                                                                                                              func (p *Page) IsNode() bool

                                                                                                                IsNode returns whether this is an item of one of the list types in Hugo, i.e. not a regular content page.

                                                                                                                func (*Page) IsPage

                                                                                                                func (p *Page) IsPage() bool

                                                                                                                  IsPage returns whether this is a regular content page.

                                                                                                                  func (*Page) IsRenderable

                                                                                                                  func (p *Page) IsRenderable() bool

                                                                                                                  func (*Page) IsSection

                                                                                                                  func (p *Page) IsSection() bool

                                                                                                                    IsSection returns whether this is a section page.

                                                                                                                    func (*Page) IsTranslated

                                                                                                                    func (p *Page) IsTranslated() bool

                                                                                                                      IsTranslated returns whether this content file is translated to other language(s).

                                                                                                                      func (*Page) Lang

                                                                                                                      func (p *Page) Lang() string

                                                                                                                      func (*Page) Language

                                                                                                                      func (p *Page) Language() *langs.Language

                                                                                                                      func (*Page) LanguagePrefix

                                                                                                                      func (p *Page) LanguagePrefix() string

                                                                                                                      func (*Page) LinkTitle

                                                                                                                      func (p *Page) LinkTitle() string

                                                                                                                      func (*Page) MediaType

                                                                                                                      func (p *Page) MediaType() media.Type

                                                                                                                      func (*Page) Menus

                                                                                                                      func (p *Page) Menus() PageMenus

                                                                                                                      func (*Page) Name

                                                                                                                      func (p *Page) Name() string

                                                                                                                        See resource.Resource This value is used, by default, in Resources.ByPrefix etc.

                                                                                                                        func (*Page) OutputFormats

                                                                                                                        func (p *Page) OutputFormats() OutputFormats

                                                                                                                          OutputFormats gives the output formats for this Page.

                                                                                                                          func (*Page) Paginate

                                                                                                                          func (p *Page) Paginate(seq interface{}, options ...interface{}) (*Pager, error)

                                                                                                                            Paginate invokes this Page's main output's Paginate method.

                                                                                                                            func (*Page) Paginator

                                                                                                                            func (p *Page) Paginator(options ...interface{}) (*Pager, error)

                                                                                                                              Paginator get this Page's main output's paginator.

                                                                                                                              func (*Page) Param

                                                                                                                              func (p *Page) Param(key interface{}) (interface{}, error)

                                                                                                                                Param is a convenience method to do lookups in Page's and Site's Params map, in that order.

                                                                                                                                This method is also implemented on Node and SiteInfo.

                                                                                                                                func (*Page) Params

                                                                                                                                func (p *Page) Params() map[string]interface{}

                                                                                                                                func (*Page) Parent

                                                                                                                                func (p *Page) Parent() *Page

                                                                                                                                  Parent returns a section's parent section or a page's section. To get a section's subsections, see Page's Sections method.

                                                                                                                                  func (p *Page) Permalink() string

                                                                                                                                    Permalink returns the absolute URL to this Page.

                                                                                                                                    func (*Page) Plain

                                                                                                                                    func (p *Page) Plain() string

                                                                                                                                    func (*Page) PlainWords

                                                                                                                                    func (p *Page) PlainWords() []string

                                                                                                                                    func (*Page) PubDate

                                                                                                                                    func (p *Page) PubDate() time.Time

                                                                                                                                      PubDate is when this page was or will be published. NOTE: This is currently used for search only and is not meant to be used directly in templates. We need to consolidate the dates in this struct. TODO(bep) see https://github.com/gohugoio/hugo/issues/3854

                                                                                                                                      func (p *Page) RSSLink() template.URL

                                                                                                                                      func (*Page) RawContent

                                                                                                                                      func (p *Page) RawContent() string

                                                                                                                                      func (*Page) ReadFrom

                                                                                                                                      func (p *Page) ReadFrom(buf io.Reader) (int64, error)

                                                                                                                                      func (*Page) ReadingTime

                                                                                                                                      func (p *Page) ReadingTime() int

                                                                                                                                      func (*Page) Ref

                                                                                                                                      func (p *Page) Ref(argsm map[string]interface{}) (string, error)
                                                                                                                                      func (p *Page) RelPermalink() string

                                                                                                                                        RelPermalink gets a URL to the resource relative to the host.

                                                                                                                                        func (*Page) RelRef

                                                                                                                                        func (p *Page) RelRef(argsm map[string]interface{}) (string, error)

                                                                                                                                        func (*Page) Render

                                                                                                                                        func (p *Page) Render(layout ...string) template.HTML

                                                                                                                                        func (*Page) ResourceType

                                                                                                                                        func (*Page) ResourceType() string

                                                                                                                                        func (*Page) SafeSaveSourceAs

                                                                                                                                        func (p *Page) SafeSaveSourceAs(path string) error

                                                                                                                                        func (*Page) SaveSource

                                                                                                                                        func (p *Page) SaveSource() error

                                                                                                                                        func (*Page) SaveSourceAs

                                                                                                                                        func (p *Page) SaveSourceAs(path string) error

                                                                                                                                        func (*Page) Scratch

                                                                                                                                        func (p *Page) Scratch() *maps.Scratch

                                                                                                                                          Scratch returns the writable context associated with this Page.

                                                                                                                                          func (*Page) SearchKeywords

                                                                                                                                          func (p *Page) SearchKeywords(cfg related.IndexConfig) ([]related.Keyword, error)

                                                                                                                                            SearchKeywords implements the related.Document interface needed for fast page searches.

                                                                                                                                            func (*Page) Section

                                                                                                                                            func (p *Page) Section() string

                                                                                                                                              Section returns the first path element below the content root. Note that since Hugo 0.22 we support nested sections, but this will always be the first element of any nested path.

                                                                                                                                              func (*Page) Sections

                                                                                                                                              func (p *Page) Sections() Pages

                                                                                                                                                Sections returns this section's subsections, if any. Note that for non-sections, this method will always return an empty list.

                                                                                                                                                func (*Page) SetSourceContent

                                                                                                                                                func (p *Page) SetSourceContent(content []byte)

                                                                                                                                                func (*Page) SetSourceMetaData

                                                                                                                                                func (p *Page) SetSourceMetaData(in interface{}, mark rune) (err error)

                                                                                                                                                func (*Page) Sites

                                                                                                                                                func (p *Page) Sites() SiteInfos

                                                                                                                                                  Sites is a convenience method to get all the Hugo sites/languages configured.

                                                                                                                                                  func (*Page) String

                                                                                                                                                  func (p *Page) String() string

                                                                                                                                                  func (*Page) Summary

                                                                                                                                                  func (p *Page) Summary() template.HTML

                                                                                                                                                  func (*Page) Title

                                                                                                                                                  func (p *Page) Title() string

                                                                                                                                                  func (*Page) TranslationKey

                                                                                                                                                  func (p *Page) TranslationKey() string

                                                                                                                                                    TranslationKey returns the key used to map language translations of this page. It will use the translationKey set in front matter if set, or the content path and filename (excluding any language code and extension), e.g. "about/index". The Page Kind is always prepended.

                                                                                                                                                    func (*Page) Translations

                                                                                                                                                    func (p *Page) Translations() Pages

                                                                                                                                                      Translations returns the translations excluding the current Page.

                                                                                                                                                      func (*Page) Truncated

                                                                                                                                                      func (p *Page) Truncated() bool

                                                                                                                                                      func (*Page) Type

                                                                                                                                                      func (p *Page) Type() string

                                                                                                                                                      func (*Page) URL

                                                                                                                                                      func (p *Page) URL() string

                                                                                                                                                      func (*Page) UniqueID

                                                                                                                                                      func (p *Page) UniqueID() string

                                                                                                                                                      func (*Page) WordCount

                                                                                                                                                      func (p *Page) WordCount() int

                                                                                                                                                      type PageCollections

                                                                                                                                                      type PageCollections struct {
                                                                                                                                                      	// Includes only pages of all types, and only pages in the current language.
                                                                                                                                                      	Pages Pages
                                                                                                                                                      
                                                                                                                                                      	// Includes all pages in all languages, including the current one.
                                                                                                                                                      	// Includes pages of all types.
                                                                                                                                                      	AllPages Pages
                                                                                                                                                      
                                                                                                                                                      	// A convenience cache for the regular pages.
                                                                                                                                                      	// This is for the current language only.
                                                                                                                                                      	RegularPages Pages
                                                                                                                                                      
                                                                                                                                                      	// A convenience cache for the all the regular pages.
                                                                                                                                                      	AllRegularPages Pages
                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                      }

                                                                                                                                                        PageCollections contains the page collections for a site.

                                                                                                                                                        type PageGenealogist

                                                                                                                                                        type PageGenealogist interface {
                                                                                                                                                        
                                                                                                                                                        	// Template example:
                                                                                                                                                        	// {{ $related := .RegularPages.Related . }}
                                                                                                                                                        	Related(doc related.Document) (Pages, error)
                                                                                                                                                        
                                                                                                                                                        	// Template example:
                                                                                                                                                        	// {{ $related := .RegularPages.RelatedIndices . "tags" "date" }}
                                                                                                                                                        	RelatedIndices(doc related.Document, indices ...interface{}) (Pages, error)
                                                                                                                                                        
                                                                                                                                                        	// Template example:
                                                                                                                                                        	// {{ $related := .RegularPages.RelatedTo ( keyVals "tags" "hugo", "rocks")  ( keyVals "date" .Date ) }}
                                                                                                                                                        	RelatedTo(args ...types.KeyValues) (Pages, error)
                                                                                                                                                        }

                                                                                                                                                          A PageGenealogist finds related pages in a page collection. This interface is implemented by Pages and PageGroup, which makes it available as `{{ .RegularPages.Related . }}` etc.

                                                                                                                                                          type PageGroup

                                                                                                                                                          type PageGroup struct {
                                                                                                                                                          	Key interface{}
                                                                                                                                                          	Pages
                                                                                                                                                          }

                                                                                                                                                            PageGroup represents a group of pages, grouped by the key. The key is typically a year or similar.

                                                                                                                                                            type PageMenus map[string]*MenuEntry

                                                                                                                                                              PageMenus is a dictionary of menus defined in the Pages.

                                                                                                                                                              type PageMeta

                                                                                                                                                              type PageMeta struct {
                                                                                                                                                              	Weight int
                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                              }

                                                                                                                                                              type PageOutput

                                                                                                                                                              type PageOutput struct {
                                                                                                                                                              	*Page
                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                              }

                                                                                                                                                                PageOutput represents one of potentially many output formats of a given Page.

                                                                                                                                                                func (*PageOutput) AlternativeOutputFormats

                                                                                                                                                                func (p *PageOutput) AlternativeOutputFormats() (OutputFormats, error)

                                                                                                                                                                  AlternativeOutputFormats gives the alternative output formats for this PageOutput. Note that we use the term "alternative" and not "alternate" here, as it does not necessarily replace the other format, it is an alternative representation.

                                                                                                                                                                  func (*PageOutput) Paginate

                                                                                                                                                                  func (p *PageOutput) Paginate(seq interface{}, options ...interface{}) (*Pager, error)

                                                                                                                                                                    Paginate gets this PageOutput'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 (*PageOutput) Paginator

                                                                                                                                                                    func (p *PageOutput) Paginator(options ...interface{}) (*Pager, error)

                                                                                                                                                                      Paginator gets this PageOutput's paginator if it's already created. If it's not, one will be created with all pages in Data["Pages"].

                                                                                                                                                                      func (*PageOutput) Render

                                                                                                                                                                      func (p *PageOutput) Render(layout ...string) template.HTML

                                                                                                                                                                      func (*PageOutput) Resources

                                                                                                                                                                      func (p *PageOutput) Resources() resource.Resources

                                                                                                                                                                      type PageWithoutContent

                                                                                                                                                                      type PageWithoutContent struct {
                                                                                                                                                                      	*Page
                                                                                                                                                                      }

                                                                                                                                                                        PageWithoutContent is sent to the shortcodes. They cannot access the content they're a part of. It would cause an infinite regress.

                                                                                                                                                                        Go doesn't support virtual methods, so this careful dance is currently (I think) the best we can do.

                                                                                                                                                                        func (*PageWithoutContent) Content

                                                                                                                                                                        func (p *PageWithoutContent) Content() (interface{}, error)

                                                                                                                                                                          Content returns an empty string.

                                                                                                                                                                          func (*PageWithoutContent) FuzzyWordCount

                                                                                                                                                                          func (p *PageWithoutContent) FuzzyWordCount() int

                                                                                                                                                                            FuzzyWordCount always returns 0.

                                                                                                                                                                            func (*PageWithoutContent) Plain

                                                                                                                                                                            func (p *PageWithoutContent) Plain() string

                                                                                                                                                                              Plain returns an empty string.

                                                                                                                                                                              func (*PageWithoutContent) PlainWords

                                                                                                                                                                              func (p *PageWithoutContent) PlainWords() []string

                                                                                                                                                                                PlainWords returns an empty string slice.

                                                                                                                                                                                func (*PageWithoutContent) ReadingTime

                                                                                                                                                                                func (p *PageWithoutContent) ReadingTime() int

                                                                                                                                                                                  ReadingTime always returns 0.

                                                                                                                                                                                  func (*PageWithoutContent) Summary

                                                                                                                                                                                  func (p *PageWithoutContent) Summary() template.HTML

                                                                                                                                                                                    Summary returns an empty string.

                                                                                                                                                                                    func (*PageWithoutContent) Truncated

                                                                                                                                                                                    func (p *PageWithoutContent) Truncated() bool

                                                                                                                                                                                      Truncated always returns false.

                                                                                                                                                                                      func (*PageWithoutContent) WordCount

                                                                                                                                                                                      func (p *PageWithoutContent) WordCount() int

                                                                                                                                                                                        WordCount always returns 0.

                                                                                                                                                                                        type Pager

                                                                                                                                                                                        type Pager struct {
                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                        }

                                                                                                                                                                                          Pager represents one of the elements in a paginator. The number, starting on 1, represents its place.

                                                                                                                                                                                          func (*Pager) First

                                                                                                                                                                                          func (p *Pager) First() *Pager

                                                                                                                                                                                            First returns the pager for the first page.

                                                                                                                                                                                            func (*Pager) HasNext

                                                                                                                                                                                            func (p *Pager) HasNext() bool

                                                                                                                                                                                              HasNext tests whether there are page(s) after the current.

                                                                                                                                                                                              func (*Pager) HasPrev

                                                                                                                                                                                              func (p *Pager) HasPrev() bool

                                                                                                                                                                                                HasPrev tests whether there are page(s) before the current.

                                                                                                                                                                                                func (*Pager) Last

                                                                                                                                                                                                func (p *Pager) Last() *Pager

                                                                                                                                                                                                  Last returns the pager for the last page.

                                                                                                                                                                                                  func (*Pager) Next

                                                                                                                                                                                                  func (p *Pager) Next() *Pager

                                                                                                                                                                                                    Next returns the pager for the next page.

                                                                                                                                                                                                    func (*Pager) NumberOfElements

                                                                                                                                                                                                    func (p *Pager) NumberOfElements() int

                                                                                                                                                                                                      NumberOfElements gets the number of elements on this page.

                                                                                                                                                                                                      func (*Pager) PageGroups

                                                                                                                                                                                                      func (p *Pager) PageGroups() PagesGroup

                                                                                                                                                                                                        PageGroups return Page groups for this page. Note: If this return non-empty result, then Pages() will return empty.

                                                                                                                                                                                                        func (*Pager) PageNumber

                                                                                                                                                                                                        func (p *Pager) PageNumber() int

                                                                                                                                                                                                          PageNumber returns the current page's number in the pager sequence.

                                                                                                                                                                                                          func (Pager) PageSize

                                                                                                                                                                                                          func (p Pager) PageSize() int

                                                                                                                                                                                                            PageSize returns the size of each paginator page.

                                                                                                                                                                                                            func (Pager) Pagers

                                                                                                                                                                                                            func (p Pager) Pagers() pagers

                                                                                                                                                                                                              Pagers returns a list of pagers that can be used to build a pagination menu.

                                                                                                                                                                                                              func (*Pager) Pages

                                                                                                                                                                                                              func (p *Pager) Pages() Pages

                                                                                                                                                                                                                Pages returns the Pages on this page. Note: If this return a non-empty result, then PageGroups() will return empty.

                                                                                                                                                                                                                func (*Pager) Prev

                                                                                                                                                                                                                func (p *Pager) Prev() *Pager

                                                                                                                                                                                                                  Prev returns the pager for the previous page.

                                                                                                                                                                                                                  func (Pager) String

                                                                                                                                                                                                                  func (p Pager) String() string

                                                                                                                                                                                                                  func (Pager) TotalNumberOfElements

                                                                                                                                                                                                                  func (p Pager) TotalNumberOfElements() int

                                                                                                                                                                                                                    TotalNumberOfElements returns the number of elements on all pages in this paginator.

                                                                                                                                                                                                                    func (Pager) TotalPages

                                                                                                                                                                                                                    func (p Pager) TotalPages() int

                                                                                                                                                                                                                      TotalPages returns the number of pages in the paginator.

                                                                                                                                                                                                                      func (*Pager) URL

                                                                                                                                                                                                                      func (p *Pager) URL() template.HTML

                                                                                                                                                                                                                        URL returns the URL to the current page.

                                                                                                                                                                                                                        type Pages

                                                                                                                                                                                                                        type Pages []*Page

                                                                                                                                                                                                                        func (Pages) ByDate

                                                                                                                                                                                                                        func (p Pages) ByDate() Pages

                                                                                                                                                                                                                          ByDate sorts the Pages by date and returns a copy.

                                                                                                                                                                                                                          Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                          This may safely be executed in parallel.

                                                                                                                                                                                                                          func (Pages) ByExpiryDate

                                                                                                                                                                                                                          func (p Pages) ByExpiryDate() Pages

                                                                                                                                                                                                                            ByExpiryDate sorts the Pages by publish date and returns a copy.

                                                                                                                                                                                                                            Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                            This may safely be executed in parallel.

                                                                                                                                                                                                                            func (Pages) ByLanguage

                                                                                                                                                                                                                            func (p Pages) ByLanguage() Pages

                                                                                                                                                                                                                              ByLanguage sorts the Pages by the language's Weight.

                                                                                                                                                                                                                              Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                              This may safely be executed in parallel.

                                                                                                                                                                                                                              func (Pages) ByLastmod

                                                                                                                                                                                                                              func (p Pages) ByLastmod() Pages

                                                                                                                                                                                                                                ByLastmod sorts the Pages by the last modification date and returns a copy.

                                                                                                                                                                                                                                Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                                This may safely be executed in parallel.

                                                                                                                                                                                                                                func (Pages) ByLength

                                                                                                                                                                                                                                func (p Pages) ByLength() Pages

                                                                                                                                                                                                                                  ByLength sorts the Pages by length and returns a copy.

                                                                                                                                                                                                                                  Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                                  This may safely be executed in parallel.

                                                                                                                                                                                                                                  func (Pages) ByLinkTitle

                                                                                                                                                                                                                                  func (p Pages) ByLinkTitle() Pages

                                                                                                                                                                                                                                    ByLinkTitle sorts the Pages by link title and returns a copy.

                                                                                                                                                                                                                                    Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                                    This may safely be executed in parallel.

                                                                                                                                                                                                                                    func (Pages) ByParam

                                                                                                                                                                                                                                    func (p Pages) ByParam(paramsKey interface{}) Pages

                                                                                                                                                                                                                                    func (Pages) ByPublishDate

                                                                                                                                                                                                                                    func (p Pages) ByPublishDate() Pages

                                                                                                                                                                                                                                      ByPublishDate sorts the Pages by publish date and returns a copy.

                                                                                                                                                                                                                                      Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                                      This may safely be executed in parallel.

                                                                                                                                                                                                                                      func (Pages) ByTitle

                                                                                                                                                                                                                                      func (p Pages) ByTitle() Pages

                                                                                                                                                                                                                                        ByTitle sorts the Pages by title and returns a copy.

                                                                                                                                                                                                                                        Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                                        This may safely be executed in parallel.

                                                                                                                                                                                                                                        func (Pages) ByWeight

                                                                                                                                                                                                                                        func (p Pages) ByWeight() Pages

                                                                                                                                                                                                                                          ByWeight sorts the Pages by weight and returns a copy.

                                                                                                                                                                                                                                          Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                                          This may safely be executed in parallel.

                                                                                                                                                                                                                                          func (Pages) GroupBy

                                                                                                                                                                                                                                          func (p Pages) GroupBy(key string, order ...string) (PagesGroup, error)

                                                                                                                                                                                                                                            GroupBy groups by the value in the given field or method name and with the given order. Valid values for order is asc, desc, rev and reverse.

                                                                                                                                                                                                                                            func (Pages) GroupByDate

                                                                                                                                                                                                                                            func (p Pages) GroupByDate(format string, order ...string) (PagesGroup, error)

                                                                                                                                                                                                                                              GroupByDate groups by the given page's Date value in the given format and with the given order. Valid values for order is asc, desc, rev and reverse. For valid format strings, see https://golang.org/pkg/time/#Time.Format

                                                                                                                                                                                                                                              func (Pages) GroupByExpiryDate

                                                                                                                                                                                                                                              func (p Pages) GroupByExpiryDate(format string, order ...string) (PagesGroup, error)

                                                                                                                                                                                                                                                GroupByExpiryDate groups by the given page's ExpireDate value in the given format and with the given order. Valid values for order is asc, desc, rev and reverse. For valid format strings, see https://golang.org/pkg/time/#Time.Format

                                                                                                                                                                                                                                                func (Pages) GroupByParam

                                                                                                                                                                                                                                                func (p Pages) GroupByParam(key string, order ...string) (PagesGroup, error)

                                                                                                                                                                                                                                                  GroupByParam groups by the given page parameter key's value and with the given order. Valid values for order is asc, desc, rev and reverse.

                                                                                                                                                                                                                                                  func (Pages) GroupByParamDate

                                                                                                                                                                                                                                                  func (p Pages) GroupByParamDate(key string, format string, order ...string) (PagesGroup, error)

                                                                                                                                                                                                                                                    GroupByParamDate groups by a date set as a param on the page in the given format and with the given order. Valid values for order is asc, desc, rev and reverse. For valid format strings, see https://golang.org/pkg/time/#Time.Format

                                                                                                                                                                                                                                                    func (Pages) GroupByPublishDate

                                                                                                                                                                                                                                                    func (p Pages) GroupByPublishDate(format string, order ...string) (PagesGroup, error)

                                                                                                                                                                                                                                                      GroupByPublishDate groups by the given page's PublishDate value in the given format and with the given order. Valid values for order is asc, desc, rev and reverse. For valid format strings, see https://golang.org/pkg/time/#Time.Format

                                                                                                                                                                                                                                                      func (Pages) Len

                                                                                                                                                                                                                                                      func (p Pages) Len() int

                                                                                                                                                                                                                                                        Len returns the number of pages in the list.

                                                                                                                                                                                                                                                        func (Pages) Limit

                                                                                                                                                                                                                                                        func (p Pages) Limit(n int) Pages

                                                                                                                                                                                                                                                          Limit limits the number of pages returned to n.

                                                                                                                                                                                                                                                          func (Pages) MergeByLanguage

                                                                                                                                                                                                                                                          func (p1 Pages) MergeByLanguage(p2 Pages) Pages

                                                                                                                                                                                                                                                            MergeByLanguage supplies missing translations in p1 with values from p2. The result is sorted by the default sort order for pages.

                                                                                                                                                                                                                                                            func (Pages) MergeByLanguageInterface

                                                                                                                                                                                                                                                            func (p1 Pages) MergeByLanguageInterface(in interface{}) (interface{}, error)

                                                                                                                                                                                                                                                              MergeByLanguageInterface is the generic version of MergeByLanguage. It is here just so it can be called from the tpl package.

                                                                                                                                                                                                                                                              func (Pages) Next

                                                                                                                                                                                                                                                              func (p Pages) Next(cur *Page) *Page

                                                                                                                                                                                                                                                                Next returns the next page reletive to the given page.

                                                                                                                                                                                                                                                                func (Pages) Prev

                                                                                                                                                                                                                                                                func (p Pages) Prev(cur *Page) *Page

                                                                                                                                                                                                                                                                  Prev returns the previous page reletive to the given page.

                                                                                                                                                                                                                                                                  func (Pages) Related

                                                                                                                                                                                                                                                                  func (p Pages) Related(doc related.Document) (Pages, error)

                                                                                                                                                                                                                                                                    Related searches all the configured indices with the search keywords from the supplied document.

                                                                                                                                                                                                                                                                    func (Pages) RelatedIndices

                                                                                                                                                                                                                                                                    func (p Pages) RelatedIndices(doc related.Document, indices ...interface{}) (Pages, error)

                                                                                                                                                                                                                                                                      RelatedIndices searches the given indices with the search keywords from the supplied document.

                                                                                                                                                                                                                                                                      func (Pages) RelatedTo

                                                                                                                                                                                                                                                                      func (p Pages) RelatedTo(args ...types.KeyValues) (Pages, error)

                                                                                                                                                                                                                                                                        RelatedTo searches the given indices with the corresponding values.

                                                                                                                                                                                                                                                                        func (Pages) Reverse

                                                                                                                                                                                                                                                                        func (p Pages) Reverse() Pages

                                                                                                                                                                                                                                                                          Reverse reverses the order in Pages and returns a copy.

                                                                                                                                                                                                                                                                          Adjacent invocations on the same receiver will return a cached result.

                                                                                                                                                                                                                                                                          This may safely be executed in parallel.

                                                                                                                                                                                                                                                                          func (Pages) Sort

                                                                                                                                                                                                                                                                          func (p Pages) Sort()

                                                                                                                                                                                                                                                                            Sort sorts the pages by the default sort order defined: Order by Weight, Date, LinkTitle and then full file path.

                                                                                                                                                                                                                                                                            func (Pages) String

                                                                                                                                                                                                                                                                            func (ps Pages) String() string

                                                                                                                                                                                                                                                                            type PagesGroup

                                                                                                                                                                                                                                                                            type PagesGroup []PageGroup

                                                                                                                                                                                                                                                                              PagesGroup represents a list of page groups. This is what you get when doing page grouping in the templates.

                                                                                                                                                                                                                                                                              func (PagesGroup) Len

                                                                                                                                                                                                                                                                              func (psg PagesGroup) Len() int

                                                                                                                                                                                                                                                                                Len returns the number of pages in the page group.

                                                                                                                                                                                                                                                                                func (PagesGroup) Reverse

                                                                                                                                                                                                                                                                                func (p PagesGroup) Reverse() PagesGroup

                                                                                                                                                                                                                                                                                  Reverse reverses the order of this list of page groups.

                                                                                                                                                                                                                                                                                  type PermalinkOverrides

                                                                                                                                                                                                                                                                                  type PermalinkOverrides map[string]pathPattern

                                                                                                                                                                                                                                                                                    PermalinkOverrides maps a section name to a PathPattern

                                                                                                                                                                                                                                                                                    type Permalinker

                                                                                                                                                                                                                                                                                    type Permalinker interface {
                                                                                                                                                                                                                                                                                    	Permalink() string
                                                                                                                                                                                                                                                                                    	RelPermalink() string
                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                      Permalinker provides permalinks of both the relative and absolute kind.

                                                                                                                                                                                                                                                                                      type Position

                                                                                                                                                                                                                                                                                      type Position struct {
                                                                                                                                                                                                                                                                                      	Prev          *Page
                                                                                                                                                                                                                                                                                      	Next          *Page
                                                                                                                                                                                                                                                                                      	PrevInSection *Page
                                                                                                                                                                                                                                                                                      	NextInSection *Page
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                      type ShortcodeWithPage

                                                                                                                                                                                                                                                                                      type ShortcodeWithPage struct {
                                                                                                                                                                                                                                                                                      	Params        interface{}
                                                                                                                                                                                                                                                                                      	Inner         template.HTML
                                                                                                                                                                                                                                                                                      	Page          *PageWithoutContent
                                                                                                                                                                                                                                                                                      	Parent        *ShortcodeWithPage
                                                                                                                                                                                                                                                                                      	IsNamedParams bool
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      	// Zero-based ordinal in relation to its parent. If the parent is the page itself,
                                                                                                                                                                                                                                                                                      	// this ordinal will represent the position of this shortcode in the page content.
                                                                                                                                                                                                                                                                                      	Ordinal int
                                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                        ShortcodeWithPage is the "." context in a shortcode template.

                                                                                                                                                                                                                                                                                        func (*ShortcodeWithPage) Get

                                                                                                                                                                                                                                                                                        func (scp *ShortcodeWithPage) Get(key interface{}) interface{}

                                                                                                                                                                                                                                                                                          Get is a convenience method to look up shortcode parameters by its key.

                                                                                                                                                                                                                                                                                          func (*ShortcodeWithPage) Ref

                                                                                                                                                                                                                                                                                          func (scp *ShortcodeWithPage) Ref(args map[string]interface{}) (string, error)

                                                                                                                                                                                                                                                                                            Ref is a shortcut to the Ref method on Page.

                                                                                                                                                                                                                                                                                            func (*ShortcodeWithPage) RelRef

                                                                                                                                                                                                                                                                                            func (scp *ShortcodeWithPage) RelRef(args map[string]interface{}) (string, error)

                                                                                                                                                                                                                                                                                              RelRef is a shortcut to the RelRef method on Page.

                                                                                                                                                                                                                                                                                              func (*ShortcodeWithPage) Scratch

                                                                                                                                                                                                                                                                                              func (scp *ShortcodeWithPage) Scratch() *maps.Scratch

                                                                                                                                                                                                                                                                                                Scratch returns a scratch-pad scoped for this shortcode. This can be used as a temporary storage for variables, counters etc.

                                                                                                                                                                                                                                                                                                func (*ShortcodeWithPage) Site

                                                                                                                                                                                                                                                                                                func (scp *ShortcodeWithPage) Site() *SiteInfo

                                                                                                                                                                                                                                                                                                  Site returns information about the current site.

                                                                                                                                                                                                                                                                                                  type Site

                                                                                                                                                                                                                                                                                                  type Site struct {
                                                                                                                                                                                                                                                                                                  	*PageCollections
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	Taxonomies TaxonomyList
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	Sections Taxonomy
                                                                                                                                                                                                                                                                                                  	Info     SiteInfo
                                                                                                                                                                                                                                                                                                  	Menus    Menus
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	Data     map[string]interface{}
                                                                                                                                                                                                                                                                                                  	Language *langs.Language
                                                                                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                                                                                  	// Logger etc.
                                                                                                                                                                                                                                                                                                  	*deps.Deps `json:"-"`
                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                    Site contains all the information relevant for constructing a static site. The basic flow of information is as follows:

                                                                                                                                                                                                                                                                                                    1. A list of Files is parsed and then converted into Pages.

                                                                                                                                                                                                                                                                                                    2. Pages contain sections (based on the file they were generated from),

                                                                                                                                                                                                                                                                                                    aliases and slugs (included in a pages frontmatter) which are the
                                                                                                                                                                                                                                                                                                    various targets that will get generated.  There will be canonical
                                                                                                                                                                                                                                                                                                    listing.  The canonical path can be overruled based on a pattern.
                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                    3. Taxonomies are created via configuration and will present some aspect of

                                                                                                                                                                                                                                                                                                    the final page and typically a perm url.
                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                    4. All Pages are passed through a template based on their desired

                                                                                                                                                                                                                                                                                                    layout based on numerous different elements.
                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                    5. The entire collection of files is written to disk.

                                                                                                                                                                                                                                                                                                    func NewEnglishSite

                                                                                                                                                                                                                                                                                                    func NewEnglishSite(withTemplate ...func(templ tpl.TemplateHandler) error) (*Site, error)

                                                                                                                                                                                                                                                                                                      NewEnglishSite creates a new site in English language. The site will have a template system loaded and ready to use. Note: This is mainly used in single site tests. TODO(bep) test refactor -- remove

                                                                                                                                                                                                                                                                                                      func NewSite

                                                                                                                                                                                                                                                                                                      func NewSite(cfg deps.DepsCfg) (*Site, error)

                                                                                                                                                                                                                                                                                                        NewSite creates a new site with the given dependency configuration. The site will have a template system loaded and ready to use. Note: This is mainly used in single site tests.

                                                                                                                                                                                                                                                                                                        func NewSiteDefaultLang

                                                                                                                                                                                                                                                                                                        func NewSiteDefaultLang(withTemplate ...func(templ tpl.TemplateHandler) error) (*Site, error)

                                                                                                                                                                                                                                                                                                          NewSiteDefaultLang creates a new site in the default language. The site will have a template system loaded and ready to use. Note: This is mainly used in single site tests. TODO(bep) test refactor -- remove

                                                                                                                                                                                                                                                                                                          func NewSiteForCfg

                                                                                                                                                                                                                                                                                                          func NewSiteForCfg(cfg deps.DepsCfg) (*Site, error)

                                                                                                                                                                                                                                                                                                            NewSiteForCfg creates a new site for the given configuration. The site will have a template system loaded and ready to use. Note: This is mainly used in single site tests.

                                                                                                                                                                                                                                                                                                            func (*Site) Initialise

                                                                                                                                                                                                                                                                                                            func (s *Site) Initialise() (err error)

                                                                                                                                                                                                                                                                                                            func (*Site) NewPage

                                                                                                                                                                                                                                                                                                            func (s *Site) NewPage(name string) (*Page, error)

                                                                                                                                                                                                                                                                                                            func (*Site) NewPageFrom

                                                                                                                                                                                                                                                                                                            func (s *Site) NewPageFrom(buf io.Reader, name string) (*Page, error)

                                                                                                                                                                                                                                                                                                            func (*Site) RegisterMediaTypes

                                                                                                                                                                                                                                                                                                            func (s *Site) RegisterMediaTypes()

                                                                                                                                                                                                                                                                                                              RegisterMediaTypes will register the Site's media types in the mime package, so it will behave correctly with Hugo's built-in server.

                                                                                                                                                                                                                                                                                                              type SiteConfig

                                                                                                                                                                                                                                                                                                              type SiteConfig struct {
                                                                                                                                                                                                                                                                                                              	// This contains all privacy related settings that can be used to
                                                                                                                                                                                                                                                                                                              	// make the YouTube template etc. GDPR compliant.
                                                                                                                                                                                                                                                                                                              	Privacy privacy.Config
                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                              	// Services contains config for services such as Google Analytics etc.
                                                                                                                                                                                                                                                                                                              	Services services.Config
                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                SiteConfig represents the config in .Site.Config.

                                                                                                                                                                                                                                                                                                                type SiteInfo

                                                                                                                                                                                                                                                                                                                type SiteInfo struct {
                                                                                                                                                                                                                                                                                                                	Taxonomies TaxonomyList
                                                                                                                                                                                                                                                                                                                	Authors    AuthorList
                                                                                                                                                                                                                                                                                                                	Social     SiteSocial
                                                                                                                                                                                                                                                                                                                	*PageCollections
                                                                                                                                                                                                                                                                                                                	Menus        *Menus
                                                                                                                                                                                                                                                                                                                	Hugo         *HugoInfo
                                                                                                                                                                                                                                                                                                                	Title        string
                                                                                                                                                                                                                                                                                                                	RSSLink      string
                                                                                                                                                                                                                                                                                                                	Author       map[string]interface{}
                                                                                                                                                                                                                                                                                                                	LanguageCode string
                                                                                                                                                                                                                                                                                                                	Copyright    string
                                                                                                                                                                                                                                                                                                                	LastChange   time.Time
                                                                                                                                                                                                                                                                                                                	Permalinks   PermalinkOverrides
                                                                                                                                                                                                                                                                                                                	Params       map[string]interface{}
                                                                                                                                                                                                                                                                                                                	BuildDrafts  bool
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	Data *map[string]interface{}
                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                	Language       *langs.Language
                                                                                                                                                                                                                                                                                                                	LanguagePrefix string
                                                                                                                                                                                                                                                                                                                	Languages      langs.Languages
                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                func (*SiteInfo) BaseURL

                                                                                                                                                                                                                                                                                                                func (s *SiteInfo) BaseURL() template.URL

                                                                                                                                                                                                                                                                                                                func (*SiteInfo) Config

                                                                                                                                                                                                                                                                                                                func (s *SiteInfo) Config() SiteConfig

                                                                                                                                                                                                                                                                                                                func (*SiteInfo) DisqusShortname

                                                                                                                                                                                                                                                                                                                func (s *SiteInfo) DisqusShortname() string

                                                                                                                                                                                                                                                                                                                  DisqusShortname is kept here for historic reasons.

                                                                                                                                                                                                                                                                                                                  func (*SiteInfo) GetPage

                                                                                                                                                                                                                                                                                                                  func (s *SiteInfo) GetPage(ref ...string) (*Page, error)

                                                                                                                                                                                                                                                                                                                    GetPage looks up a page of a given type for the given ref. In Hugo <= 0.44 you had to add Page Kind (section, home) etc. as the first argument and then either a unix styled path (with or without a leading slash)) or path elements separated. When we now remove the Kind from this API, we need to make the transition as painless as possible for existing sites. Most sites will use {{ .Site.GetPage "section" "my/section" }}, i.e. 2 arguments, so we test for that.

                                                                                                                                                                                                                                                                                                                    func (*SiteInfo) GoogleAnalytics

                                                                                                                                                                                                                                                                                                                    func (s *SiteInfo) GoogleAnalytics() string

                                                                                                                                                                                                                                                                                                                      GoogleAnalytics is kept here for historic reasons.

                                                                                                                                                                                                                                                                                                                      func (*SiteInfo) Home

                                                                                                                                                                                                                                                                                                                      func (s *SiteInfo) Home() (*Page, error)

                                                                                                                                                                                                                                                                                                                        Home is a shortcut to the home page, equivalent to .Site.GetPage "home".

                                                                                                                                                                                                                                                                                                                        func (*SiteInfo) HomeAbsURL

                                                                                                                                                                                                                                                                                                                        func (s *SiteInfo) HomeAbsURL() string

                                                                                                                                                                                                                                                                                                                          HomeAbsURL is a convenience method giving the absolute URL to the home page.

                                                                                                                                                                                                                                                                                                                          func (*SiteInfo) IsMultiLingual

                                                                                                                                                                                                                                                                                                                          func (s *SiteInfo) IsMultiLingual() bool

                                                                                                                                                                                                                                                                                                                          func (*SiteInfo) IsServer

                                                                                                                                                                                                                                                                                                                          func (s *SiteInfo) IsServer() bool

                                                                                                                                                                                                                                                                                                                          func (*SiteInfo) Param

                                                                                                                                                                                                                                                                                                                          func (s *SiteInfo) Param(key interface{}) (interface{}, error)

                                                                                                                                                                                                                                                                                                                            Param is a convenience method to do lookups in SiteInfo's Params map.

                                                                                                                                                                                                                                                                                                                            This method is also implemented on Page and Node.

                                                                                                                                                                                                                                                                                                                            func (*SiteInfo) Ref

                                                                                                                                                                                                                                                                                                                            func (s *SiteInfo) Ref(ref string, page *Page, options ...string) (string, error)

                                                                                                                                                                                                                                                                                                                              Ref will give an absolute URL to ref in the given Page.

                                                                                                                                                                                                                                                                                                                              func (*SiteInfo) RelRef

                                                                                                                                                                                                                                                                                                                              func (s *SiteInfo) RelRef(ref string, page *Page, options ...string) (string, error)

                                                                                                                                                                                                                                                                                                                                RelRef will give an relative URL to ref in the given Page.

                                                                                                                                                                                                                                                                                                                                func (*SiteInfo) Sections

                                                                                                                                                                                                                                                                                                                                func (s *SiteInfo) Sections() Pages

                                                                                                                                                                                                                                                                                                                                  Sections returns the top level sections.

                                                                                                                                                                                                                                                                                                                                  func (*SiteInfo) ServerPort

                                                                                                                                                                                                                                                                                                                                  func (s *SiteInfo) ServerPort() int

                                                                                                                                                                                                                                                                                                                                    ServerPort returns the port part of the BaseURL, 0 if none found.

                                                                                                                                                                                                                                                                                                                                    func (*SiteInfo) SitemapAbsURL

                                                                                                                                                                                                                                                                                                                                    func (s *SiteInfo) SitemapAbsURL() string

                                                                                                                                                                                                                                                                                                                                      SitemapAbsURL is a convenience method giving the absolute URL to the sitemap.

                                                                                                                                                                                                                                                                                                                                      func (*SiteInfo) String

                                                                                                                                                                                                                                                                                                                                      func (s *SiteInfo) String() string

                                                                                                                                                                                                                                                                                                                                      type SiteInfos

                                                                                                                                                                                                                                                                                                                                      type SiteInfos []*SiteInfo

                                                                                                                                                                                                                                                                                                                                      func (SiteInfos) First

                                                                                                                                                                                                                                                                                                                                      func (s SiteInfos) First() *SiteInfo

                                                                                                                                                                                                                                                                                                                                        First is a convenience method to get the first Site, i.e. the main language.

                                                                                                                                                                                                                                                                                                                                        type SiteSocial

                                                                                                                                                                                                                                                                                                                                        type SiteSocial map[string]string

                                                                                                                                                                                                                                                                                                                                          SiteSocial is a place to put social details on a site level. These are the standard keys that themes will expect to have available, but can be expanded to any others on a per site basis github facebook facebook_admin twitter twitter_domain googleplus pinterest instagram youtube linkedin

                                                                                                                                                                                                                                                                                                                                          type Sitemap

                                                                                                                                                                                                                                                                                                                                          type Sitemap struct {
                                                                                                                                                                                                                                                                                                                                          	ChangeFreq string
                                                                                                                                                                                                                                                                                                                                          	Priority   float64
                                                                                                                                                                                                                                                                                                                                          	Filename   string
                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                            Sitemap configures the sitemap to be generated.

                                                                                                                                                                                                                                                                                                                                            type Source

                                                                                                                                                                                                                                                                                                                                            type Source struct {
                                                                                                                                                                                                                                                                                                                                            	Frontmatter []byte
                                                                                                                                                                                                                                                                                                                                            	Content     []byte
                                                                                                                                                                                                                                                                                                                                            	source.File
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                            type Taxonomy

                                                                                                                                                                                                                                                                                                                                            type Taxonomy map[string]WeightedPages

                                                                                                                                                                                                                                                                                                                                              A Taxonomy is a map of keywords to a list of pages. For example

                                                                                                                                                                                                                                                                                                                                              TagTaxonomy['technology'] = WeightedPages
                                                                                                                                                                                                                                                                                                                                              TagTaxonomy['go']  =  WeightedPages2
                                                                                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                                                                                              func (Taxonomy) Alphabetical

                                                                                                                                                                                                                                                                                                                                              func (i Taxonomy) Alphabetical() OrderedTaxonomy

                                                                                                                                                                                                                                                                                                                                                Alphabetical returns an ordered taxonomy sorted by key name.

                                                                                                                                                                                                                                                                                                                                                func (Taxonomy) ByCount

                                                                                                                                                                                                                                                                                                                                                func (i Taxonomy) ByCount() OrderedTaxonomy

                                                                                                                                                                                                                                                                                                                                                  ByCount returns an ordered taxonomy sorted by # of pages per key. If taxonomies have the same # of pages, sort them alphabetical

                                                                                                                                                                                                                                                                                                                                                  func (Taxonomy) Count

                                                                                                                                                                                                                                                                                                                                                  func (i Taxonomy) Count(key string) int

                                                                                                                                                                                                                                                                                                                                                    Count the weighted pages for the given key.

                                                                                                                                                                                                                                                                                                                                                    func (Taxonomy) Get

                                                                                                                                                                                                                                                                                                                                                    func (i Taxonomy) Get(key string) WeightedPages

                                                                                                                                                                                                                                                                                                                                                      Get the weighted pages for the given key.

                                                                                                                                                                                                                                                                                                                                                      func (Taxonomy) TaxonomyArray

                                                                                                                                                                                                                                                                                                                                                      func (i Taxonomy) TaxonomyArray() OrderedTaxonomy

                                                                                                                                                                                                                                                                                                                                                        TaxonomyArray returns an ordered taxonomy with a non defined order.

                                                                                                                                                                                                                                                                                                                                                        type TaxonomyList

                                                                                                                                                                                                                                                                                                                                                        type TaxonomyList map[string]Taxonomy

                                                                                                                                                                                                                                                                                                                                                          The TaxonomyList is a list of all taxonomies and their values e.g. List['tags'] => TagTaxonomy (from above)

                                                                                                                                                                                                                                                                                                                                                          func (TaxonomyList) String

                                                                                                                                                                                                                                                                                                                                                          func (tl TaxonomyList) String() string

                                                                                                                                                                                                                                                                                                                                                          type Translations

                                                                                                                                                                                                                                                                                                                                                          type Translations map[string]*Page

                                                                                                                                                                                                                                                                                                                                                            Translations represent the other translations for a given page. The string here is the language code, as affected by the `post.LANG.md` filename.

                                                                                                                                                                                                                                                                                                                                                            type Video

                                                                                                                                                                                                                                                                                                                                                            type Video struct {
                                                                                                                                                                                                                                                                                                                                                            	ThumbnailLoc         string
                                                                                                                                                                                                                                                                                                                                                            	Title                string
                                                                                                                                                                                                                                                                                                                                                            	Description          string
                                                                                                                                                                                                                                                                                                                                                            	ContentLoc           string
                                                                                                                                                                                                                                                                                                                                                            	PlayerLoc            string
                                                                                                                                                                                                                                                                                                                                                            	Duration             string
                                                                                                                                                                                                                                                                                                                                                            	ExpirationDate       string
                                                                                                                                                                                                                                                                                                                                                            	Rating               string
                                                                                                                                                                                                                                                                                                                                                            	ViewCount            string
                                                                                                                                                                                                                                                                                                                                                            	PublicationDate      string
                                                                                                                                                                                                                                                                                                                                                            	FamilyFriendly       string
                                                                                                                                                                                                                                                                                                                                                            	Restriction          string
                                                                                                                                                                                                                                                                                                                                                            	GalleryLoc           string
                                                                                                                                                                                                                                                                                                                                                            	Price                string
                                                                                                                                                                                                                                                                                                                                                            	RequiresSubscription string
                                                                                                                                                                                                                                                                                                                                                            	Uploader             string
                                                                                                                                                                                                                                                                                                                                                            	Live                 string
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              A Video contains metadata for videos + video sitemaps https://support.google.com/webmasters/answer/80471?hl=en

                                                                                                                                                                                                                                                                                                                                                              type WeightedPage

                                                                                                                                                                                                                                                                                                                                                              type WeightedPage struct {
                                                                                                                                                                                                                                                                                                                                                              	Weight int
                                                                                                                                                                                                                                                                                                                                                              	*Page
                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                A WeightedPage is a Page with a weight.

                                                                                                                                                                                                                                                                                                                                                                func (WeightedPage) String

                                                                                                                                                                                                                                                                                                                                                                func (w WeightedPage) String() string

                                                                                                                                                                                                                                                                                                                                                                type WeightedPages

                                                                                                                                                                                                                                                                                                                                                                type WeightedPages []WeightedPage

                                                                                                                                                                                                                                                                                                                                                                  WeightedPages is a list of Pages with their corresponding (and relative) weight [{Weight: 30, Page: *1}, {Weight: 40, Page: *2}]

                                                                                                                                                                                                                                                                                                                                                                  func (WeightedPages) Count

                                                                                                                                                                                                                                                                                                                                                                  func (wp WeightedPages) Count() int

                                                                                                                                                                                                                                                                                                                                                                    Count returns the number of pages in this weighted page set.

                                                                                                                                                                                                                                                                                                                                                                    func (WeightedPages) Len

                                                                                                                                                                                                                                                                                                                                                                    func (wp WeightedPages) Len() int

                                                                                                                                                                                                                                                                                                                                                                    func (WeightedPages) Less

                                                                                                                                                                                                                                                                                                                                                                    func (wp WeightedPages) Less(i, j int) bool

                                                                                                                                                                                                                                                                                                                                                                    func (WeightedPages) Next

                                                                                                                                                                                                                                                                                                                                                                    func (wp WeightedPages) Next(cur *Page) *Page

                                                                                                                                                                                                                                                                                                                                                                      Next returns the next Page relative to the given Page in this weighted page set.

                                                                                                                                                                                                                                                                                                                                                                      func (WeightedPages) Pages

                                                                                                                                                                                                                                                                                                                                                                      func (wp WeightedPages) Pages() Pages

                                                                                                                                                                                                                                                                                                                                                                        Pages returns the Pages in this weighted page set.

                                                                                                                                                                                                                                                                                                                                                                        func (WeightedPages) Prev

                                                                                                                                                                                                                                                                                                                                                                        func (wp WeightedPages) Prev(cur *Page) *Page

                                                                                                                                                                                                                                                                                                                                                                          Prev returns the previous Page relative to the given Page in this weighted page set.

                                                                                                                                                                                                                                                                                                                                                                          func (WeightedPages) Sort

                                                                                                                                                                                                                                                                                                                                                                          func (wp WeightedPages) Sort()

                                                                                                                                                                                                                                                                                                                                                                            Sort stable sorts this weighted page set.

                                                                                                                                                                                                                                                                                                                                                                            func (WeightedPages) Swap

                                                                                                                                                                                                                                                                                                                                                                            func (wp WeightedPages) Swap(i, j int)

                                                                                                                                                                                                                                                                                                                                                                            Directories

                                                                                                                                                                                                                                                                                                                                                                            Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                            Package filesystems provides the fine grained file systems used by Hugo.
                                                                                                                                                                                                                                                                                                                                                                            Package filesystems provides the fine grained file systems used by Hugo.