buf: github.com/bufbuild/buf/internal/pkg/normalpath Index | Files

package normalpath

import "github.com/bufbuild/buf/internal/pkg/normalpath"

Package normalpath provides functions similar to filepath.

A normalized path is a cleaned and to-slash'ed path. A validated path validates that a path is relative and does not jump context.

Index

Package Files

normalpath.go

func Base Uses

func Base(path string) string

Base is equivalent to filepath.Base.

Normalizes before returning.

func ByDir Uses

func ByDir(paths ...string) map[string][]string

ByDir maps the paths into a map from directory via Dir to the original paths.

The paths for each value slice will be sorted.

The path is expected to be normalized.

func Components Uses

func Components(path string) []string

Components splits the path into it's components.

This calls filepath.Split repeatedly.

The path is expected to be normalized.

func ContainsPath Uses

func ContainsPath(dirPath string, path string, pathType PathType) bool

ContainsPath returns true if the dirPath contains the path.

The path and value are expected to be normalized and validated if Relative is used. The path and value are expected to be normalized and absolute if Absolute is used.

For a given dirPath:

- If path == PathType, dirPath does not contain the path.
- If dirPath == PathType, the dirPath contains the path.
- If dirPath is a directory that contains path, this returns true.

func Dir Uses

func Dir(path string) string

Dir is equivalent to filepath.Dir.

Normalizes before returning.

func EqualsOrContainsPath Uses

func EqualsOrContainsPath(value string, path string, pathType PathType) bool

EqualsOrContainsPath returns true if the value is equal to or contains the path.

The path and value are expected to be normalized and validated if Relative is used. The path and value are expected to be normalized and absolute if Absolute is used.

For a given value:

- If value == PathType, the value contains the path.
- If value == path, the value is equal to the path.
- If value is a directory that contains path, this returns true.

func Ext Uses

func Ext(path string) string

Ext is equivalent to filepath.Ext.

Can return empty string.

func Join Uses

func Join(paths ...string) string

Join is equivalent to filepath.Join.

Empty strings are ignored, Can return empty string.

Normalizes before returning otherwise.

func MapAllEqualOrContainingPaths Uses

func MapAllEqualOrContainingPaths(m map[string]struct{}, path string, pathType PathType) []string

MapAllEqualOrContainingPaths returns the matching paths in the map.

The path and all keys in m are expected to be normalized and validated.

For a given key x:

- If x == PathType, the path always matches.
- If x == path, the path matches.
- If x is a directory that contains path, the path matches.

If the map is empty, returns nil.

func MapHasEqualOrContainingPath Uses

func MapHasEqualOrContainingPath(m map[string]struct{}, path string, pathType PathType) bool

MapHasEqualOrContainingPath returns true if the path matches any file or directory in the map.

The path and value are expected to be normalized and validated if Relative is used. The path and value are expected to be normalized and absolute if Absolute is used.

For a given key x:

- If x == PathType, the path always matches.
- If x == path, the path matches.
- If x is a directory that contains path, the path matches.

If the map is empty, returns false.

func Normalize Uses

func Normalize(path string) string

Normalize normalizes the given path.

This calls filepath.Clean and filepath.ToSlash on the path. If the path is "" or ".", this returns ".".

func NormalizeAndAbsolute Uses

func NormalizeAndAbsolute(path string) (string, error)

NormalizeAndAbsolute normalizes the path and makes it absolute.

func NormalizeAndTransformForPathType Uses

func NormalizeAndTransformForPathType(path string, pathType PathType) (string, error)

NormalizeAndTransformForPathType calls NormalizeAndValidate for relative paths, and NormalizeAndAbsolute for absolute paths.

func NormalizeAndValidate Uses

func NormalizeAndValidate(path string) (string, error)

NormalizeAndValidate normalizes and validates the given path.

This calls Normalize on the path. Returns Error if the path is not relative or jumps context. This can be used to validate that paths are valid to use with Buckets. The error message is safe to pass to users.

func Rel Uses

func Rel(basepath string, targpath string) (string, error)

Rel is equivalent to filepath.Rel.

Can return empty string, especially on error.

Normalizes before returning otherwise.

func StripComponents Uses

func StripComponents(path string, countUint32 uint32) (string, bool)

StripComponents strips the specified number of components.

Path expected to be normalized. Returns false if the path does not have more than the specified number of components.

func Unnormalize Uses

func Unnormalize(path string) string

Unnormalize unnormalizes the given path.

This calls filepath.FromSlash on the path. If the path is "", this returns "".

func ValidatePathComponent Uses

func ValidatePathComponent(component string) error

ValidatePathComponent validates that the string is a valid component of a path, e.g. it can be Joined and form a valid path.

func ValidatePathComponents Uses

func ValidatePathComponents(components ...string) error

ValidatePathComponents validates that all the strings are valid components of a path, e.g. they can be Joined and form a valid path.

type Error Uses

type Error struct {
    Path string
    Err  error
}

Error is a path error.

func NewError Uses

func NewError(path string, err error) *Error

NewError returns a new Error.

func (*Error) Error Uses

func (e *Error) Error() string

Error implements error.

func (*Error) Is Uses

func (e *Error) Is(err error) bool

Is implements errors.Is for Error.

func (*Error) Unwrap Uses

func (e *Error) Unwrap() error

Unwrap implements errors.Unwrap for Error.

type PathType Uses

type PathType int

PathType is a terminate type for path comparisons.

const (
    // Relative is the PathType for normalized and validated paths.
    Relative PathType = 1
    // Absolute is the PathType for normalized and absolute paths.
    Absolute PathType = 2
)

func (PathType) Separator Uses

func (t PathType) Separator() string

Separator gets the string value of the separator.

TODO: rename to Terminator if we keep this TODO: we should probably refactor so we never need to use absolute paths at all this could be accomplished if we could for ExternalPathToRelPath on buckets

Package normalpath imports 8 packages (graph) and is imported by 25 packages. Updated 2020-10-20. Refresh now. Tools for package owners.