mirror of
https://github.com/Jguer/yay.git
synced 2024-11-06 17:17:22 +01:00
9c882614a3
Bash seperates on whitespace, so the fish completion file
actually works for bash and zsh. So remove the concept of shells
entirley and just use the singular aur_sh.cache file.
If for some reason output without the repository data is needed, the
user could always just pipe it into awk like so
`yay -Pc | awk '{print $1}'`. Or perhaps a --quiet option could be added
where yay will strip the output itself.
The completion cache now updates when installing AUR packages. This is
done as a goroutine with no wait groups. This ensures the program will
never hang if there is a problem.
The completion is stil updated during -Pc but as long as an AUR package
has been installed recently it should not need to update.
The cache will now also wait 7 days instead of 2 before refreshing.
A refresh can be forced using -Pcc.
92 lines
1.7 KiB
Go
92 lines
1.7 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
alpm "github.com/jguer/go-alpm"
|
|
)
|
|
|
|
//CreateAURList creates a new completion file
|
|
func createAURList(out *os.File) (err error) {
|
|
resp, err := http.Get("https://aur.archlinux.org/packages.gz")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer resp.Body.Close()
|
|
|
|
scanner := bufio.NewScanner(resp.Body)
|
|
|
|
scanner.Scan()
|
|
for scanner.Scan() {
|
|
out.WriteString(scanner.Text())
|
|
out.WriteString("\tAUR\n")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
//CreatePackageList appends Repo packages to completion cache
|
|
func createRepoList(out *os.File) (err error) {
|
|
dbList, err := alpmHandle.SyncDbs()
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
_ = dbList.ForEach(func(db alpm.Db) error {
|
|
_ = db.PkgCache().ForEach(func(pkg alpm.Package) error {
|
|
out.WriteString(pkg.Name())
|
|
out.WriteString("\t" + pkg.DB().Name() + "\n")
|
|
return nil
|
|
})
|
|
return nil
|
|
})
|
|
return nil
|
|
}
|
|
|
|
func updateCompletion(force bool) error {
|
|
path := filepath.Join(cacheHome, "completion.cache")
|
|
info, err := os.Stat(path)
|
|
|
|
if os.IsNotExist(err) || time.Since(info.ModTime()).Hours() >= 7*24 || force {
|
|
os.MkdirAll(filepath.Dir(path), 0755)
|
|
out, errf := os.Create(path)
|
|
if errf != nil {
|
|
return errf
|
|
}
|
|
|
|
if createAURList(out) != nil {
|
|
defer os.Remove(path)
|
|
}
|
|
erra := createRepoList(out)
|
|
|
|
out.Close()
|
|
return erra
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Complete provides completion info for shells
|
|
func complete(force bool) error {
|
|
path := filepath.Join(cacheHome, "completion.cache")
|
|
|
|
err := updateCompletion(force)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
in, err := os.OpenFile(path, os.O_RDWR|os.O_CREATE, 0644)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer in.Close()
|
|
|
|
_, err = io.Copy(os.Stdout, in)
|
|
return err
|
|
}
|