hugo: Index | Files

package output

import ""


Package Files

docshelper.go layout.go layout_base.go outputFormat.go


var (
    // An ordered list of built-in output formats
    // See
    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",

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

type Format Uses

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
    // AMP has a special requirement in this department, see:
    // I.e.:
    // <link rel="amphtml" href="">
    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 Uses

func (formats Format) BaseFilename() string

func (Format) MarshalJSON Uses

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

type Formats Uses

type Formats []Format

func DecodeFormats Uses

func DecodeFormats(mediaTypes media.Types, maps[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 Uses

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

FromFilename gets a Format given a filename.

func (Formats) GetByName Uses

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

GetByName gets a format by its identifier name.

func (Formats) GetByNames Uses

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

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

func (Formats) GetBySuffix Uses

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 Uses

func (formats Formats) Len() int

func (Formats) Less Uses

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

func (Formats) Swap Uses

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

type LayoutDescriptor Uses

type LayoutDescriptor struct {
    Type    string
    Section string
    Kind    string
    Lang    string
    Layout  string

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

type LayoutHandler Uses

type LayoutHandler struct {
    // contains filtered or unexported fields

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

func NewLayoutHandler Uses

func NewLayoutHandler(hasTheme bool) *LayoutHandler

NewLayoutHandler creates a new LayoutHandler.

func (*LayoutHandler) For Uses

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

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

type TemplateLookupDescriptor Uses

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 Uses

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 Uses

func CreateTemplateNames(d TemplateLookupDescriptor) (TemplateNames, error)

Package output imports 12 packages (graph) and is imported by 19 packages. Updated 2017-11-20. Refresh now. Tools for package owners.