output

Documentation

Index

• Variables
• type Format
  • func (formats Format) BaseFilename() string
  • func (formats Format) MarshalJSON() ([]byte, error)
• type Formats
  • func DecodeFormats(mediaTypes media.Types, maps ...map[string]interface{}) (Formats, error)
  • func (formats Formats) FromFilename(filename string) (f Format, found bool)
  • func (formats Formats) GetByName(name string) (f Format, found bool)
  • func (formats Formats) GetByNames(names ...string) (Formats, error)
  • func (formats Formats) GetBySuffix(suffix string) (f Format, found bool)
  • func (formats Formats) Len() int
  • func (formats Formats) Less(i, j int) bool
  • func (formats Formats) Swap(i, j int)
• type LayoutDescriptor
• type LayoutHandler
  • func NewLayoutHandler(hasTheme bool) *LayoutHandler
  • func (l *LayoutHandler) For(d LayoutDescriptor, f Format) ([]string, error)
• type TemplateLookupDescriptor
• type TemplateNames
  • func CreateTemplateNames(d TemplateLookupDescriptor) (TemplateNames, error)

Variables

var (
	// An ordered list of built-in output formats
	//
	// See https://www.ampproject.org/learn/overview/
	AMPFormat = Format{
		Name:      "AMP",
		MediaType: media.HTMLType,
		BaseName:  "index",
		Path:      "amp",
		Rel:       "amphtml",
		IsHTML:    true,
	}

	CalendarFormat = Format{
		Name:        "Calendar",
		MediaType:   media.CalendarType,
		IsPlainText: true,
		Protocol:    "webcal://",
		BaseName:    "index",
		Rel:         "alternate",
	}

	CSSFormat = Format{
		Name:           "CSS",
		MediaType:      media.CSSType,
		BaseName:       "styles",
		IsPlainText:    true,
		Rel:            "stylesheet",
		NotAlternative: true,
	}
	CSVFormat = Format{
		Name:        "CSV",
		MediaType:   media.CSVType,
		BaseName:    "index",
		IsPlainText: true,
		Rel:         "alternate",
	}

	HTMLFormat = Format{
		Name:      "HTML",
		MediaType: media.HTMLType,
		BaseName:  "index",
		Rel:       "canonical",
		IsHTML:    true,
	}

	JSONFormat = Format{
		Name:        "JSON",
		MediaType:   media.JSONType,
		BaseName:    "index",
		IsPlainText: true,
		Rel:         "alternate",
	}

	RobotsTxtFormat = Format{
		Name:        "ROBOTS",
		MediaType:   media.TextType,
		BaseName:    "robots",
		IsPlainText: true,
		Rel:         "alternate",
	}

	RSSFormat = Format{
		Name:      "RSS",
		MediaType: media.RSSType,
		BaseName:  "index",
		NoUgly:    true,
		Rel:       "alternate",
	}

	SitemapFormat = Format{
		Name:      "Sitemap",
		MediaType: media.XMLType,
		BaseName:  "sitemap",
		NoUgly:    true,
		Rel:       "sitemap",
	}
)

var DefaultFormats = Formats{
	AMPFormat,
	CalendarFormat,
	CSSFormat,
	CSVFormat,
	HTMLFormat,
	JSONFormat,
	RobotsTxtFormat,
	RSSFormat,
	SitemapFormat,
}

Types

type Format

type Format struct {
	// The Name is used as an identifier. Internal output formats (i.e. HTML and RSS)
	// can be overridden by providing a new definition for those types.
	Name string `json:"name"`

	MediaType media.Type `json:"mediaType"`

	// Must be set to a value when there are two or more conflicting mediatype for the same resource.
	Path string `json:"path"`

	// The base output file name used when not using "ugly URLs", defaults to "index".
	BaseName string `json:"baseName"`

	// The value to use for rel links
	//
	// See https://www.w3schools.com/tags/att_link_rel.asp
	//
	// AMP has a special requirement in this department, see:
	// https://www.ampproject.org/docs/guides/deploy/discovery
	// I.e.:
	// <link rel="amphtml" href="https://www.example.com/url/to/amp/document.html">
	Rel string `json:"rel"`

	// The protocol to use, i.e. "webcal://". Defaults to the protocol of the baseURL.
	Protocol string `json:"protocol"`

	// IsPlainText decides whether to use text/template or html/template
	// as template parser.
	IsPlainText bool `json:"isPlainText"`

	// IsHTML returns whether this format is int the HTML family. This includes
	// HTML, AMP etc. This is used to decide when to create alias redirects etc.
	IsHTML bool `json:"isHTML"`

	// Enable to ignore the global uglyURLs setting.
	NoUgly bool `json:"noUgly"`

	// Enable if it doesn't make sense to include this format in an alternative
	// format listing, CSS being one good example.
	// 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.
	NotAlternative bool `json:"notAlternative"`
}

Format represents an output representation, usually to a file on disk.

func (Format) BaseFilename

func (formats Format) BaseFilename() string

func (Format) MarshalJSON

func (formats Format) MarshalJSON() ([]byte, error)

type Formats

type Formats []Format

func DecodeFormats

func DecodeFormats(mediaTypes media.Types, maps ...map[string]interface{}) (Formats, error)

DecodeFormats takes a list of output format configurations and merges those, in the order given, with the Hugo defaults as the last resort.

func (Formats) FromFilename

func (formats Formats) FromFilename(filename string) (f Format, found bool)

FromFilename gets a Format given a filename.

func (Formats) GetByName

func (formats Formats) GetByName(name string) (f Format, found bool)

GetByName gets a format by its identifier name.

func (Formats) GetByNames

func (formats Formats) GetByNames(names ...string) (Formats, error)

GetByNames gets a list of formats given a list of identifiers.

func (Formats) GetBySuffix

func (formats Formats) GetBySuffix(suffix string) (f Format, found bool)

GetBySuffix gets a output format given as suffix, e.g. "html". It will return false if no format could be found, or if the suffix given is ambiguous. The lookup is case insensitive.

func (Formats) Len

func (formats Formats) Len() int

func (Formats) Less

func (formats Formats) Less(i, j int) bool

func (Formats) Swap

func (formats Formats) Swap(i, j int)

type LayoutDescriptor

type LayoutDescriptor struct {
	Type    string
	Section string
	Kind    string
	Lang    string
	Layout  string
	// LayoutOverride indicates what we should only look for the above layout.
	LayoutOverride bool
}

LayoutDescriptor describes how a layout should be chosen. This is typically built from a Page.

type LayoutHandler

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

LayoutHandler calculates the layout template to use to render a given output type.

func NewLayoutHandler

func NewLayoutHandler(hasTheme bool) *LayoutHandler

NewLayoutHandler creates a new LayoutHandler.

func (*LayoutHandler) For

func (l *LayoutHandler) For(d LayoutDescriptor, f Format) ([]string, error)

For returns a layout for the given LayoutDescriptor and options. Layouts are rendered and cached internally.

type TemplateLookupDescriptor

type TemplateLookupDescriptor struct {
	// TemplateDir is the project or theme root of the current template.
	// This will be the same as WorkingDir for non-theme templates.
	TemplateDir string

	// The full path to the site root.
	WorkingDir string

	// Main project layout dir, defaults to "layouts"
	LayoutDir string

	// The path to the template relative the the base.
	//  I.e. shortcodes/youtube.html
	RelPath string

	// The template name prefix to look for, i.e. "theme".
	Prefix string

	// The theme dir if theme active.
	ThemeDir string

	// All the output formats in play. This is used to decide if text/template or
	// html/template.
	OutputFormats Formats

	FileExists  func(filename string) (bool, error)
	ContainsAny func(filename string, subslices [][]byte) (bool, error)
}

type TemplateNames

type TemplateNames struct {
	// The name used as key in the template map. Note that this will be
	// prefixed with "_text/" if it should be parsed with text/template.
	Name string

	OverlayFilename string
	MasterFilename  string
}

func CreateTemplateNames

func CreateTemplateNames(d TemplateLookupDescriptor) (TemplateNames, error)