hugo: github.com/gohugoio/hugo/resources/resource Index | Files

package resource

import "github.com/gohugoio/hugo/resources/resource"

Index

Package Files

dates.go params.go resource_helpers.go resources.go resourcetypes.go

func GetParam Uses

func GetParam(r Resource, key string) interface{}

GetParam will return the param with the given key from the Resource, nil if not found.

func GetParamToLower Uses

func GetParamToLower(r Resource, key string) interface{}

GetParamToLower is the same as GetParam but it will lower case any string result, including string slices.

func IsExpired Uses

func IsExpired(d Dated) bool

IsExpired returns whether the argument is expired.

func IsFuture Uses

func IsFuture(d Dated) bool

IsFuture returns whether the argument represents the future.

func IsZeroDates Uses

func IsZeroDates(d Dated) bool

IsZeroDates returns true if all of the dates are zero.

func Param Uses

func Param(r ResourceParamsProvider, fallback maps.Params, key interface{}) (interface{}, error)

type Cloner Uses

type Cloner interface {
    Clone() Resource
}

Cloner is an internal template and not meant for use in the templates. It may change without notice.

type ContentProvider Uses

type ContentProvider interface {
    // Content returns this resource's content. It will be equivalent to reading the content
    // that RelPermalink points to in the published folder.
    // The return type will be contextual, and should be what you would expect:
    // * Page: template.HTML
    // * JSON: String
    // * Etc.
    Content() (interface{}, error)
}

ContentProvider provides Content. This should be used with care, as it will read the file content into memory, but it should be cached as effectively as possible by the implementation.

type ContentResource Uses

type ContentResource interface {
    MediaType() media.Type
    ContentProvider
}

ContentResource represents a Resource that provides a way to get to its content. Most Resource types in Hugo implements this interface, including Page.

type Dated Uses

type Dated interface {
    Date() time.Time
    Lastmod() time.Time
    PublishDate() time.Time
    ExpiryDate() time.Time
}

Dated wraps a "dated resource". These are the 4 dates that makes the date logic in Hugo.

type Dates Uses

type Dates struct {
    FDate        time.Time
    FLastmod     time.Time
    FPublishDate time.Time
    FExpiryDate  time.Time
}

Dates holds the 4 Hugo dates.

func (Dates) Date Uses

func (p Dates) Date() time.Time

func (Dates) ExpiryDate Uses

func (p Dates) ExpiryDate() time.Time

func (Dates) Lastmod Uses

func (p Dates) Lastmod() time.Time

func (Dates) PublishDate Uses

func (p Dates) PublishDate() time.Time

func (*Dates) UpdateDateAndLastmodIfAfter Uses

func (d *Dates) UpdateDateAndLastmodIfAfter(in Dated)

type Identifier Uses

type Identifier interface {
    Key() string
}

Identifier identifies a resource.

type Image Uses

type Image interface {
    Resource
    ImageOps
}

Image represents an image resource.

type ImageOps Uses

type ImageOps interface {
    Height() int
    Width() int
    Fill(spec string) (Image, error)
    Fit(spec string) (Image, error)
    Resize(spec string) (Image, error)
    Filter(filters ...interface{}) (Image, error)
    Exif() (*exif.Exif, error)
}

type LanguageProvider Uses

type LanguageProvider interface {
    Language() *langs.Language
}

LanguageProvider is a Resource in a language.

func NewLanguageProvider Uses

func NewLanguageProvider(lang *langs.Language) LanguageProvider

type LengthProvider Uses

type LengthProvider interface {
    Len() int
}

LengthProvider is a Resource that provides a length (typically the length of the content).

type MediaTypeProvider Uses

type MediaTypeProvider interface {
    // MediaType is this resource's MIME type.
    MediaType() media.Type
}

type OpenReadSeekCloser Uses

type OpenReadSeekCloser func() (hugio.ReadSeekCloser, error)

OpenReadSeekCloser allows setting some other way (than reading from a filesystem) to open or create a ReadSeekCloser.

type OriginProvider Uses

type OriginProvider interface {
    Origin() Resource
    GetFieldString(pattern string) (string, bool)
}

OriginProvider provides the original Resource if this is wrapped. This is an internal Hugo interface and not meant for use in the templates.

type ReadSeekCloserProvider Uses

type ReadSeekCloserProvider interface {
    ReadSeekCloser() (hugio.ReadSeekCloser, error)
}

type ReadSeekCloserResource Uses

type ReadSeekCloserResource interface {
    MediaType() media.Type
    ReadSeekCloserProvider
}

ReadSeekCloserResource is a Resource that supports loading its content.

type Resource Uses

type Resource interface {
    ResourceTypeProvider
    MediaTypeProvider
    ResourceLinksProvider
    ResourceMetaProvider
    ResourceParamsProvider
    ResourceDataProvider
}

Resource represents a linkable resource, i.e. a content page, image etc.

type ResourceDataProvider Uses

type ResourceDataProvider interface {
    // Resource specific data set by Hugo.
    // One example would be.Data.Digest for fingerprinted resources.
    Data() interface{}
}

type ResourceLinksProvider Uses

type ResourceLinksProvider interface {
    // Permalink represents the absolute link to this resource.
    Permalink() string

    // RelPermalink represents the host relative link to this resource.
    RelPermalink() string
}

type ResourceMetaProvider Uses

type ResourceMetaProvider interface {
    // Name is the logical name of this resource. This can be set in the front matter
    // metadata for this resource. If not set, Hugo will assign a value.
    // This will in most cases be the base filename.
    // So, for the image "/some/path/sunset.jpg" this will be "sunset.jpg".
    // The value returned by this method will be used in the GetByPrefix and ByPrefix methods
    // on Resources.
    Name() string

    // Title returns the title if set in front matter. For content pages, this will be the expected value.
    Title() string
}

type ResourceParamsProvider Uses

type ResourceParamsProvider interface {
    // Params set in front matter for this resource.
    Params() maps.Params
}

type ResourceTypeProvider Uses

type ResourceTypeProvider interface {
    // ResourceType is the resource type. For most file types, this is the main
    // part of the MIME type, e.g. "image", "application", "text" etc.
    // For content pages, this value is "page".
    ResourceType() string
}

type ResourceTypesProvider Uses

type ResourceTypesProvider interface {
    ResourceTypeProvider
    MediaTypeProvider
}

func NewResourceTypesProvider Uses

func NewResourceTypesProvider(mediaType media.Type, resourceType string) ResourceTypesProvider

type Resources Uses

type Resources []Resource

Resources represents a slice of resources, which can be a mix of different types. I.e. both pages and images etc.

func (Resources) ByType Uses

func (r Resources) ByType(tp string) Resources

ByType returns resources of a given resource type (ie. "image").

func (Resources) GetMatch Uses

func (r Resources) GetMatch(pattern string) Resource

GetMatch finds the first Resource matching the given pattern, or nil if none found. See Match for a more complete explanation about the rules used.

func (Resources) Match Uses

func (r Resources) Match(pattern string) Resources

Match gets all resources matching the given base filename prefix, e.g "*.png" will match all png files. The "*" does not match path delimiters (/), so if you organize your resources in sub-folders, you need to be explicit about it, e.g.: "images/*.png". To match any PNG image anywhere in the bundle you can do "**.png", and to match all PNG images below the images folder, use "images/**.jpg". The matching is case insensitive. Match matches by using the value of Resource.Name, which, by default, is a filename with path relative to the bundle root with Unix style slashes (/) and no leading slash, e.g. "images/logo.png". See https://github.com/gobwas/glob for the full rules set.

func (Resources) MergeByLanguage Uses

func (r Resources) MergeByLanguage(r2 Resources) Resources

MergeByLanguage adds missing translations in r1 from r2.

func (Resources) MergeByLanguageInterface Uses

func (r Resources) 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.

type ResourcesConverter Uses

type ResourcesConverter interface {
    ToResources() Resources
}

ResourcesConverter converts a given slice of Resource objects to Resources.

type ResourcesLanguageMerger Uses

type ResourcesLanguageMerger interface {
    MergeByLanguage(other Resources) Resources
    // Needed for integration with the tpl package.
    MergeByLanguageInterface(other interface{}) (interface{}, error)
}

ResourcesLanguageMerger describes an interface for merging resources from a different language.

type Source Uses

type Source interface {
    Publish() error
}

Source is an internal template and not meant for use in the templates. It may change without notice.

type TranslationKeyProvider Uses

type TranslationKeyProvider interface {
    TranslationKey() string
}

TranslationKeyProvider connects translations of the same Resource.

type UnmarshableResource Uses

type UnmarshableResource interface {
    ReadSeekCloserResource
    Identifier
}

UnmarshableResource represents a Resource that can be unmarshaled to some other format.

Package resource imports 11 packages (graph) and is imported by 85 packages. Updated 2020-07-14. Refresh now. Tools for package owners.