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

package resources

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

Index

Package Files

image.go image_cache.go post_publish.go resource.go resource_cache.go resource_metadata.go resource_spec.go transform.go

Constants

const (
    CACHE_CLEAR_ALL = "clear_all"
    CACHE_OTHER     = "other"
)

func AssignMetadata Uses

func AssignMetadata(metadata []map[string]interface{}, resources ...resource.Resource) error

AssignMetadata assigns the given metadata to those resources that supports updates and matching by wildcard given in `src` using `filepath.Match` with lower cased values. This assignment is additive, but the most specific match needs to be first. The `name` and `title` metadata field support shell-matched collection it got a match in. See https://golang.org/pkg/path/#Match

func ResourceCacheKey Uses

func ResourceCacheKey(filename string) string

ResourceCacheKey converts the filename into the format used in the resource cache.

func ResourceKeyContainsAny Uses

func ResourceKeyContainsAny(key string, partitions []string) bool

ResourceKeyContainsAny returns whether the key is a member of any of the given partitions.

This is used for resource cache invalidation.

func ResourceKeyPartitions Uses

func ResourceKeyPartitions(filename string) []string

ResourceKeyPartitions resolves a ordered slice of partitions that is used to do resource cache invalidations.

We use the first directory path element and the extension, so:

a/b.json => "a", "json"
b.json => "json"

For some of the extensions we will also map to closely related types, e.g. "scss" will also return "sass".

type ResourceCache Uses

type ResourceCache struct {
    sync.RWMutex
    // contains filtered or unexported fields
}

func (*ResourceCache) Contains Uses

func (c *ResourceCache) Contains(key string) bool

func (*ResourceCache) DeleteContains Uses

func (c *ResourceCache) DeleteContains(parts ...string)

func (*ResourceCache) DeletePartitions Uses

func (c *ResourceCache) DeletePartitions(partitions ...string)

func (*ResourceCache) GetOrCreate Uses

func (c *ResourceCache) GetOrCreate(key string, f func() (resource.Resource, error)) (resource.Resource, error)

func (*ResourceCache) GetOrCreateResources Uses

func (c *ResourceCache) GetOrCreateResources(key string, f func() (resource.Resources, error)) (resource.Resources, error)

type ResourceSourceDescriptor Uses

type ResourceSourceDescriptor struct {
    // TargetPaths is a callback to fetch paths's relative to its owner.
    TargetPaths func() page.TargetPaths

    // Need one of these to load the resource content.
    SourceFile         source.File
    OpenReadSeekCloser resource.OpenReadSeekCloser

    FileInfo os.FileInfo

    // If OpenReadSeekerCloser is not set, we use this to open the file.
    SourceFilename string

    Fs  afero.Fs

    // The relative target filename without any language code.
    RelTargetFilename string

    // Any base paths prepended to the target path. This will also typically be the
    // language code, but setting it here means that it should not have any effect on
    // the permalink.
    // This may be several values. In multihost mode we may publish the same resources to
    // multiple targets.
    TargetBasePaths []string

    // Delay publishing until either Permalink or RelPermalink is called. Maybe never.
    LazyPublish bool
}

func (ResourceSourceDescriptor) Filename Uses

func (r ResourceSourceDescriptor) Filename() string

type ResourceTransformation Uses

type ResourceTransformation interface {
    Key() internal.ResourceTransformationKey
    Transform(ctx *ResourceTransformationCtx) error
}

ResourceTransformation is the interface that a resource transformation step needs to implement.

func NewFeatureNotAvailableTransformer Uses

func NewFeatureNotAvailableTransformer(key string, elements ...interface{}) ResourceTransformation

type ResourceTransformationCtx Uses

type ResourceTransformationCtx struct {
    // The content to transform.
    From io.Reader

    // The target of content transformation.
    // The current implementation requires that r is written to w
    // even if no transformation is performed.
    To  io.Writer

    // This is the relative path to the original source. Unix styled slashes.
    SourcePath string

    // This is the relative target path to the resource. Unix styled slashes.
    InPath string

    // The relative target path to the transformed resource. Unix styled slashes.
    OutPath string

    // The input media type
    InMediaType media.Type

    // The media type of the transformed resource.
    OutMediaType media.Type

    // Data data can be set on the transformed Resource. Not that this need
    // to be simple types, as it needs to be serialized to JSON and back.
    Data map[string]interface{}

    // This is used to publis additional artifacts, e.g. source maps.
    // We may improve this.
    OpenResourcePublisher func(relTargetPath string) (io.WriteCloser, error)
}

func (*ResourceTransformationCtx) AddOutPathIdentifier Uses

func (ctx *ResourceTransformationCtx) AddOutPathIdentifier(identifier string)

AddOutPathIdentifier transforming InPath to OutPath adding an identifier, eg '.min' before any extension.

func (*ResourceTransformationCtx) PublishSourceMap Uses

func (ctx *ResourceTransformationCtx) PublishSourceMap(content string) error

PublishSourceMap writes the content to the target folder of the main resource with the ".map" extension added.

func (*ResourceTransformationCtx) ReplaceOutPathExtension Uses

func (ctx *ResourceTransformationCtx) ReplaceOutPathExtension(newExt string)

ReplaceOutPathExtension transforming InPath to OutPath replacing the file extension, e.g. ".scss"

type ResourceTransformer Uses

type ResourceTransformer interface {
    resource.Resource
    Transformer
}

type Spec Uses

type Spec struct {
    *helpers.PathSpec

    MediaTypes    media.Types
    OutputFormats output.Formats

    Logger      *loggers.Logger
    ErrorSender herrors.ErrorSender

    TextTemplates tpl.TemplateParseFinder

    Permalinks  page.PermalinkExpander
    BuildConfig config.Build

    ResourceCache *ResourceCache
    FileCaches    filecache.Caches

    PostProcessResources map[string]postpub.PostPublishedResource
    // contains filtered or unexported fields
}

func NewSpec Uses

func NewSpec(
    s *helpers.PathSpec,
    fileCaches filecache.Caches,
    incr identity.Incrementer,
    logger *loggers.Logger,
    errorHandler herrors.ErrorSender,
    outputFormats output.Formats,
    mimeTypes media.Types) (*Spec, error)

func (*Spec) CacheStats Uses

func (r *Spec) CacheStats() string

func (*Spec) ClearCaches Uses

func (r *Spec) ClearCaches()

func (*Spec) DeleteBySubstring Uses

func (r *Spec) DeleteBySubstring(s string)

func (*Spec) New Uses

func (r *Spec) New(fd ResourceSourceDescriptor) (resource.Resource, error)

func (*Spec) PostProcess Uses

func (spec *Spec) PostProcess(r resource.Resource) (postpub.PostPublishedResource, error)

PostProcess wraps the given Resource for later processing.

func (*Spec) String Uses

func (s *Spec) String() string

type Transformer Uses

type Transformer interface {
    Transform(...ResourceTransformation) (ResourceTransformer, error)
}

Directories

PathSynopsis
imagesPackage images provides template functions for manipulating images.
images/exif
internal
pagePackage page contains the core interfaces and types for the Page resource, a core component in Hugo.
page/page_generate
page/pagemeta
postpub
resource
resource_factories/bundlerPackage bundler contains functions for concatenation etc.
resource_factories/createPackage create contains functions for to create Resource objects.
resource_transformers/babel
resource_transformers/htesting
resource_transformers/integrity
resource_transformers/js
resource_transformers/minifier
resource_transformers/postcss
resource_transformers/templatesPackage templates contains functions for template processing of Resource objects.
resource_transformers/tocss/scss

Package resources imports 45 packages (graph) and is imported by 45 packages. Updated 2020-09-21. Refresh now. Tools for package owners.