Source: glob.go in package github.com/go-git/go-billy/v5/util

package util

import (
	"path/filepath"
	"sort"
	"strings"

	"github.com/go-git/go-billy/v5"
)

Glob returns the names of all files matching pattern or nil if there is no matching file. The syntax of patterns is the same as in Match. The pattern may describe hierarchical names such as /usr/bin/ed (assuming the Separator is '/'). Glob ignores file system errors such as I/O errors reading directories. The only possible returned error is ErrBadPattern, when pattern is malformed. Function originally from https://golang.org/src/path/filepath/match_test.go

func Glob(fs billy.Filesystem, pattern string) (matches []string, err error) {
	if !hasMeta(pattern) {
		if _, err = fs.Lstat(pattern); err != nil {
			return nil, nil
		}
		return []string{pattern}, nil
	}

Prevent infinite recursion. See issue 15879.

	if dir == pattern {
		return nil, filepath.ErrBadPattern
	}

	var m []string
	m, err = Glob(fs, cleanGlobPath(dir))
	if err != nil {
		return
	}
	for _, d := range m {
		matches, err = glob(fs, d, file, matches)
		if err != nil {
			return
		}
	}
	return
}

cleanGlobPath prepares path for glob matching.

func cleanGlobPath(path string) string {
	switch path {
	case "":
		return "."

do nothing to the path

		return path
	default:
		return path[0 : len(path)-1] // chop off trailing separator
	}
}

glob searches for files matching pattern in the directory dir and appends them to matches. If the directory cannot be opened, it returns the existing matches. New matches are added in lexicographical order.

func glob(fs billy.Filesystem, dir, pattern string, matches []string) (m []string, e error) {
	m = matches
	fi, err := fs.Stat(dir)
	if err != nil {
		return
	}

	if !fi.IsDir() {
		return
	}

	names, _ := readdirnames(fs, dir)
	sort.Strings(names)

	for _, n := range names {
		matched, err := filepath.Match(pattern, n)
		if err != nil {
			return m, err
		}
		if matched {
			m = append(m, filepath.Join(dir, n))
		}
	}
	return
}

hasMeta reports whether path contains any of the magic characters recognized by Match.

TODO(niemeyer): Should other magic characters be added here?

	return strings.ContainsAny(path, "*?[")
}

func readdirnames(fs billy.Filesystem, dir string) ([]string, error) {
	files, err := fs.ReadDir(dir)
	if err != nil {
		return nil, err
	}

	var names []string
	for _, file := range files {
		names = append(names, file.Name())
	}

	return names, nil