valueobject

type BaseFileDecoratorFs struct {
	afero.Fs
	Decorate func(fi os.FileInfo, filename string) (os.FileInfo, error)
}

type BaseFs struct {

	// SourceFilesystems contains the different source file systems.
	*SourceFilesystems

	TheBigFs *FilesystemsCollector
}

type ContentClass string

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

type FileMeta struct {
	PathInfo         *paths.Path
	Name             string
	Filename         string
	Path             string
	PathWalk         string
	OriginalFilename string
	BaseDir          string

	SourceRoot string
	MountRoot  string
	Module     string

	Weight     int
	IsOrdered  bool
	IsSymlink  bool
	IsRootFile bool
	IsProject  bool
	Watch      bool

	Classifier ContentClass

	SkipDir bool

	Lang                       string
	TranslationBaseName        string
	TranslationBaseNameWithExt string
	Translations               []string

	Fs           afero.Fs
	OpenFunc     func() (afero.File, error)
	JoinStatFunc func(name string) (FileMetaInfo, error)
}

type FileMetaInfo interface {
	os.FileInfo
	Meta() *FileMeta
}

type FilesystemsCollector struct {
	SourceProject afero.Fs // Source for project folders

	OverlayMounts        *overlayfs.OverlayFs
	OverlayMountsContent *overlayfs.OverlayFs
	OverlayResources     *overlayfs.OverlayFs

	// Maps component type (layouts, static, content etc.) an ordered list of
	// directories representing the overlay filesystems above.
	OverlayDirs map[string][]FileMetaInfo
}

type RootMapping struct {
	// The virtual mount.
	From string
	// The source directory or file.
	To string
	// The base of To. May be empty if an
	// absolute path was provided.
	ToBasedir string
	// Whether this is a mount in the main project.
	IsProject bool

	Meta *FileMeta // File metadata (lang etc.)
	Fi   FileMetaInfo
	// contains filtered or unexported fields
}

type RootMappingFs struct {
	afero.Fs
	RootMapToReal *radixtree.Tree
}

type SourceFilesystem struct {
	// Name matches one in files.ComponentFolders
	Name string

	// This is a virtual composite filesystem. It expects path relative to a context.
	Fs afero.Fs

	// This filesystem as separate root directories, starting from project and down
	// to the themes/modules.
	Dirs []FileMetaInfo

	// When syncing a source folder to the target (e.g. /public), this may
	// be set to publish into a subfolder. This is used for static syncing
	// in multihost mode.
	PublishFolder string
}

type SourceFilesystems struct {
	Content    *SourceFilesystem // set
	Data       *SourceFilesystem
	I18n       *SourceFilesystem
	Layouts    *SourceFilesystem // set
	Archetypes *SourceFilesystem
	Assets     *SourceFilesystem

	// Writable filesystem on top the project's resources directory,
	// with any sub module's resource fs layered below.
	ResourcesCache afero.Fs

	// The work folder (may be a composite of project and theme components).
	Work afero.Fs

	// When in multihost we have one static filesystem per language. The sync
	// static files is currently done outside of the Hugo build (where there is
	// a concept of a site per language).
	// When in non-multihost mode there will be one entry in this map with a blank key.
	Static map[string]*SourceFilesystem

	// All the /static dirs (including themes/modules).
	StaticDirs []FileMetaInfo
}

type WalkFunc func(path string, info FileMetaInfo, err error) error

type Walkway struct {
	Fs   afero.Fs
	Root string

	WalkFn WalkFunc

	// We may traverse symbolic links and bite ourself.
	Seen map[string]bool

	Log loggers.Logger
	// contains filtered or unexported fields
}