139 lines
3.5 KiB
Go
139 lines
3.5 KiB
Go
package complete
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"github.com/posener/complete/match"
|
|
)
|
|
|
|
// Predicate determines what terms can follow a command or a flag
|
|
// It is used for auto completion, given last - the last word in the already
|
|
// in the command line, what words can complete it.
|
|
type Predicate func(last string) []match.Matcher
|
|
|
|
// Or unions two predicate functions, so that the result predicate
|
|
// returns the union of their predication
|
|
func (p Predicate) Or(other Predicate) Predicate {
|
|
if p == nil {
|
|
return other
|
|
}
|
|
if other == nil {
|
|
return p
|
|
}
|
|
return func(last string) []match.Matcher { return append(p.predict(last), other.predict(last)...) }
|
|
}
|
|
|
|
func (p Predicate) predict(last string) []match.Matcher {
|
|
if p == nil {
|
|
return nil
|
|
}
|
|
return p(last)
|
|
}
|
|
|
|
// PredictNothing does not expect anything after.
|
|
var PredictNothing Predicate
|
|
|
|
// PredictAnything expects something, but nothing particular, such as a number
|
|
// or arbitrary name.
|
|
func PredictAnything(last string) []match.Matcher { return nil }
|
|
|
|
// PredictSet expects specific set of terms, given in the options argument.
|
|
func PredictSet(options ...string) Predicate {
|
|
return func(last string) []match.Matcher {
|
|
ret := make([]match.Matcher, len(options))
|
|
for i := range options {
|
|
ret[i] = match.Prefix(options[i])
|
|
}
|
|
return ret
|
|
}
|
|
}
|
|
|
|
// PredictDirs will search for directories in the given started to be typed
|
|
// path, if no path was started to be typed, it will complete to directories
|
|
// in the current working directory.
|
|
func PredictDirs(last string) (options []match.Matcher) {
|
|
path := dirFromLast(last)
|
|
dirs := []string{}
|
|
filepath.Walk(path, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
if info.IsDir() {
|
|
dirs = append(dirs, path)
|
|
}
|
|
return nil
|
|
})
|
|
// if given path is not absolute, return relative paths
|
|
if !filepath.IsAbs(path) {
|
|
filesToRel(dirs)
|
|
}
|
|
return filesToMatchers(dirs)
|
|
}
|
|
|
|
// PredictFiles will search for files matching the given pattern in the started to
|
|
// be typed path, if no path was started to be typed, it will complete to files that
|
|
// match the pattern in the current working directory.
|
|
// To match any file, use "*" as pattern. To match go files use "*.go", and so on.
|
|
func PredictFiles(pattern string) Predicate {
|
|
return func(last string) []match.Matcher {
|
|
dir := dirFromLast(last)
|
|
files, err := filepath.Glob(filepath.Join(dir, pattern))
|
|
if err != nil {
|
|
Log("failed glob operation with pattern '%s': %s", pattern, err)
|
|
}
|
|
if !filepath.IsAbs(pattern) {
|
|
filesToRel(files)
|
|
}
|
|
return filesToMatchers(files)
|
|
}
|
|
}
|
|
|
|
// filesToRel, change list of files to their names in the relative
|
|
// to current directory form.
|
|
func filesToRel(files []string) {
|
|
wd, err := os.Getwd()
|
|
if err != nil {
|
|
return
|
|
}
|
|
for i := range files {
|
|
abs, err := filepath.Abs(files[i])
|
|
if err != nil {
|
|
continue
|
|
}
|
|
rel, err := filepath.Rel(wd, abs)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
if rel == "." {
|
|
rel = ""
|
|
}
|
|
if !strings.HasPrefix(rel, ".") {
|
|
rel = "./" + rel
|
|
}
|
|
files[i] = rel
|
|
}
|
|
return
|
|
}
|
|
|
|
func filesToMatchers(files []string) []match.Matcher {
|
|
options := make([]match.Matcher, len(files))
|
|
for i, f := range files {
|
|
options[i] = match.File(f)
|
|
}
|
|
return options
|
|
}
|
|
|
|
// dirFromLast gives the directory of the current written
|
|
// last argument if it represents a file name being written.
|
|
// in case that it is not, we fall back to the current directory.
|
|
func dirFromLast(last string) string {
|
|
dir := filepath.Dir(last)
|
|
_, err := os.Stat(dir)
|
|
if err != nil {
|
|
return "./"
|
|
}
|
|
return dir
|
|
}
|