mirror of
https://github.com/Jguer/yay
synced 2024-08-31 13:49:28 +00:00
513 lines
11 KiB
Go
513 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
)
|
|
|
|
func usage() {
|
|
fmt.Println(`usage: yay <operation> [...]
|
|
operations:
|
|
yay {-h --help}
|
|
yay {-V --version}
|
|
yay {-D --database} <options> <package(s)>
|
|
yay {-F --files} [options] [package(s)]
|
|
yay {-Q --query} [options] [package(s)]
|
|
yay {-R --remove} [options] <package(s)>
|
|
yay {-S --sync} [options] [package(s)]
|
|
yay {-T --deptest} [options] [package(s)]
|
|
yay {-U --upgrade} [options] <file(s)>
|
|
|
|
New operations:
|
|
yay -Qstats displays system information
|
|
yay -Cd remove unneeded dependencies
|
|
yay -G [package(s)] get pkgbuild from ABS or AUR
|
|
yay --gendb generates development package DB used for updating.
|
|
|
|
Permanent configuration options:
|
|
--topdown shows repository's packages first and then aur's
|
|
--bottomup shows aur's packages first and then repository's
|
|
--devel Check -git/-svn/-hg development version
|
|
--nodevel Disable development version checking
|
|
--afterclean Clean package sources after successful build
|
|
--noafterclean Disable package sources cleaning after successful build
|
|
--timeupdate Check package's modification date and version
|
|
--notimeupdate Check only package version change
|
|
|
|
New options:
|
|
--noconfirm skip user input on package install
|
|
--printconfig Prints current yay configuration
|
|
`)
|
|
}
|
|
|
|
func init() {
|
|
var configHome string // configHome handles config directory home
|
|
var cacheHome string // cacheHome handles cache home
|
|
var err error
|
|
|
|
if 0 == os.Geteuid() {
|
|
fmt.Println("Please avoid running yay as root/sudo.")
|
|
}
|
|
|
|
if configHome = os.Getenv("XDG_CONFIG_HOME"); configHome != "" {
|
|
if info, err := os.Stat(configHome); err == nil && info.IsDir() {
|
|
configHome = configHome + "/yay"
|
|
} else {
|
|
configHome = os.Getenv("HOME") + "/.config/yay"
|
|
}
|
|
} else {
|
|
configHome = os.Getenv("HOME") + "/.config/yay"
|
|
}
|
|
|
|
if cacheHome = os.Getenv("XDG_CACHE_HOME"); cacheHome != "" {
|
|
if info, err := os.Stat(cacheHome); err == nil && info.IsDir() {
|
|
cacheHome = cacheHome + "/yay"
|
|
} else {
|
|
cacheHome = os.Getenv("HOME") + "/.cache/yay"
|
|
}
|
|
} else {
|
|
cacheHome = os.Getenv("HOME") + "/.cache/yay"
|
|
}
|
|
|
|
configFile = configHome + "/config.json"
|
|
vcsFile = configHome + "/yay_vcs.json"
|
|
completionFile = cacheHome + "/aur_"
|
|
|
|
////////////////
|
|
// yay config //
|
|
////////////////
|
|
defaultSettings(&config)
|
|
|
|
if _, err = os.Stat(configFile); os.IsNotExist(err) {
|
|
err = os.MkdirAll(filepath.Dir(configFile), 0755)
|
|
if err != nil {
|
|
fmt.Println("Unable to create config directory:",
|
|
filepath.Dir(configFile), err)
|
|
os.Exit(2)
|
|
}
|
|
// Save the default config if nothing is found
|
|
config.saveConfig()
|
|
} else {
|
|
cfile, errf := os.OpenFile(configFile, os.O_RDWR|os.O_CREATE, 0644)
|
|
if errf != nil {
|
|
fmt.Println("Error reading config:", err)
|
|
} else {
|
|
defer cfile.Close()
|
|
decoder := json.NewDecoder(cfile)
|
|
err = decoder.Decode(&config)
|
|
if err != nil {
|
|
fmt.Println("Loading default Settings.\nError reading config:",
|
|
err)
|
|
defaultSettings(&config)
|
|
}
|
|
}
|
|
}
|
|
|
|
/////////////////
|
|
// vcs config //
|
|
////////////////
|
|
updated = false
|
|
|
|
vfile, err := os.Open(vcsFile)
|
|
if err == nil {
|
|
defer vfile.Close()
|
|
decoder := json.NewDecoder(vfile)
|
|
_ = decoder.Decode(&savedInfo)
|
|
}
|
|
|
|
/////////////////
|
|
// alpm config //
|
|
/////////////////
|
|
alpmConf, err = readAlpmConfig(config.PacmanConf)
|
|
if err != nil {
|
|
fmt.Println("Unable to read Pacman conf", err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
alpmHandle, err = alpmConf.CreateHandle()
|
|
if err != nil {
|
|
fmt.Println("Unable to CreateHandle", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func parser() (op string, options, packages []string, changedConfig bool, err error) {
|
|
if len(os.Args) < 2 {
|
|
err = fmt.Errorf("no operation specified")
|
|
return
|
|
}
|
|
changedConfig = false
|
|
op = "yogurt"
|
|
|
|
for _, arg := range os.Args[1:] {
|
|
if len(arg) < 2 {
|
|
continue
|
|
}
|
|
if arg[0] == '-' && arg[1] != '-' {
|
|
switch arg {
|
|
case "-V":
|
|
arg = "--version"
|
|
case "-h":
|
|
arg = "--help"
|
|
default:
|
|
op = arg
|
|
continue
|
|
}
|
|
}
|
|
|
|
if strings.HasPrefix(arg, "--") {
|
|
changedConfig = true
|
|
switch arg {
|
|
case "--afterclean":
|
|
config.CleanAfter = true
|
|
case "--noafterclean":
|
|
config.CleanAfter = false
|
|
case "--printconfig":
|
|
fmt.Printf("%#v", config)
|
|
os.Exit(0)
|
|
case "--gendb":
|
|
err = createDevelDB()
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
err = saveVCSInfo()
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
os.Exit(0)
|
|
case "--devel":
|
|
config.Devel = true
|
|
case "--nodevel":
|
|
config.Devel = false
|
|
case "--timeupdate":
|
|
config.TimeUpdate = true
|
|
case "--notimeupdate":
|
|
config.TimeUpdate = false
|
|
case "--topdown":
|
|
config.SortMode = TopDown
|
|
case "--bottomup":
|
|
config.SortMode = BottomUp
|
|
case "--complete":
|
|
config.Shell = "sh"
|
|
_ = complete()
|
|
os.Exit(0)
|
|
case "--fcomplete":
|
|
config.Shell = fishShell
|
|
_ = complete()
|
|
os.Exit(0)
|
|
case "--help":
|
|
usage()
|
|
os.Exit(0)
|
|
case "--version":
|
|
fmt.Printf("yay v%s\n", version)
|
|
os.Exit(0)
|
|
case "--noconfirm":
|
|
config.NoConfirm = true
|
|
fallthrough
|
|
default:
|
|
options = append(options, arg)
|
|
}
|
|
continue
|
|
}
|
|
packages = append(packages, arg)
|
|
}
|
|
return
|
|
}
|
|
|
|
func main() {
|
|
op, options, pkgs, changedConfig, err := parser()
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
os.Exit(1)
|
|
}
|
|
|
|
switch op {
|
|
case "-Cd":
|
|
err = cleanDependencies(pkgs)
|
|
case "-G":
|
|
for _, pkg := range pkgs {
|
|
err = getPkgbuild(pkg)
|
|
if err != nil {
|
|
fmt.Println(pkg+":", err)
|
|
}
|
|
}
|
|
case "-Qstats":
|
|
err = localStatistics()
|
|
case "-Ss", "-Ssq", "-Sqs":
|
|
if op == "-Ss" {
|
|
config.SearchMode = Detailed
|
|
} else {
|
|
config.SearchMode = Minimal
|
|
}
|
|
|
|
if pkgs != nil {
|
|
err = syncSearch(pkgs)
|
|
}
|
|
case "-S":
|
|
err = install(pkgs, options)
|
|
case "-Sy":
|
|
err = passToPacman("-Sy", nil, nil)
|
|
if err != nil {
|
|
break
|
|
}
|
|
err = install(pkgs, options)
|
|
case "-Syu", "-Suy", "-Su":
|
|
if strings.Contains(op, "y") {
|
|
err = passToPacman("-Sy", nil, nil)
|
|
if err != nil {
|
|
break
|
|
}
|
|
}
|
|
err = upgradePkgs(options)
|
|
case "-Si":
|
|
err = syncInfo(pkgs, options)
|
|
case "yogurt":
|
|
config.SearchMode = NumberMenu
|
|
|
|
if pkgs != nil {
|
|
err = numberMenu(pkgs, options)
|
|
}
|
|
default:
|
|
if op[0] == 'R' {
|
|
removeVCSPackage(pkgs)
|
|
}
|
|
err = passToPacman(op, pkgs, options)
|
|
}
|
|
|
|
var erra error
|
|
if updated {
|
|
erra = saveVCSInfo()
|
|
if erra != nil {
|
|
fmt.Println(err)
|
|
}
|
|
}
|
|
|
|
if changedConfig {
|
|
erra = config.saveConfig()
|
|
if erra != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
}
|
|
|
|
erra = alpmHandle.Release()
|
|
if erra != nil {
|
|
fmt.Println(err)
|
|
}
|
|
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
// BuildIntRange build the range from start to end
|
|
func BuildIntRange(rangeStart, rangeEnd int) []int {
|
|
if rangeEnd-rangeStart == 0 {
|
|
// rangeEnd == rangeStart, which means no range
|
|
return []int{rangeStart}
|
|
}
|
|
if rangeEnd < rangeStart {
|
|
swap := rangeEnd
|
|
rangeEnd = rangeStart
|
|
rangeStart = swap
|
|
}
|
|
|
|
final := make([]int, 0)
|
|
for i := rangeStart; i <= rangeEnd; i++ {
|
|
final = append(final, i)
|
|
}
|
|
return final
|
|
}
|
|
|
|
// BuildRange construct a range of ints from the format 1-10
|
|
func BuildRange(input string) ([]int, error) {
|
|
multipleNums := strings.Split(input, "-")
|
|
if len(multipleNums) != 2 {
|
|
return nil, errors.New("Invalid range")
|
|
}
|
|
|
|
rangeStart, err := strconv.Atoi(multipleNums[0])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rangeEnd, err := strconv.Atoi(multipleNums[1])
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return BuildIntRange(rangeStart, rangeEnd), err
|
|
}
|
|
|
|
// Contains returns wheter e is present in s
|
|
func contains(s []string, e string) bool {
|
|
for _, a := range s {
|
|
if a == e {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// RemoveIntListFromList removes all src's elements that are present in target
|
|
func removeListFromList(src, target []string) []string {
|
|
max := len(target)
|
|
for i := 0; i < max; i++ {
|
|
if contains(src, target[i]) {
|
|
target = append(target[:i], target[i+1:]...)
|
|
max--
|
|
i--
|
|
}
|
|
}
|
|
return target
|
|
}
|
|
|
|
// NumberMenu presents a CLI for selecting packages to install.
|
|
func numberMenu(pkgS []string, flags []string) (err error) {
|
|
var num int
|
|
|
|
aurQ, err := narrowSearch(pkgS, true)
|
|
if err != nil {
|
|
fmt.Println("Error during AUR search:", err)
|
|
}
|
|
numaq := len(aurQ)
|
|
repoQ, numpq, err := queryRepo(pkgS)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
if numpq == 0 && numaq == 0 {
|
|
return fmt.Errorf("no packages match search")
|
|
}
|
|
|
|
if config.SortMode == BottomUp {
|
|
aurQ.printSearch(numpq + 1)
|
|
repoQ.printSearch()
|
|
} else {
|
|
repoQ.printSearch()
|
|
aurQ.printSearch(numpq + 1)
|
|
}
|
|
|
|
fmt.Printf("\x1b[32m%s %s\x1b[0m\nNumbers: ",
|
|
"Type the numbers or ranges (e.g. 1-10) you want to install.",
|
|
"Separate each one of them with a space.")
|
|
reader := bufio.NewReader(os.Stdin)
|
|
numberBuf, overflow, err := reader.ReadLine()
|
|
if err != nil || overflow {
|
|
fmt.Println(err)
|
|
return
|
|
}
|
|
|
|
numberString := string(numberBuf)
|
|
var aurI, aurNI, repoNI, repoI []string
|
|
result := strings.Fields(numberString)
|
|
for _, numS := range result {
|
|
negate := numS[0] == '^'
|
|
if negate {
|
|
numS = numS[1:]
|
|
}
|
|
var numbers []int
|
|
num, err = strconv.Atoi(numS)
|
|
if err != nil {
|
|
numbers, err = BuildRange(numS)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
} else {
|
|
numbers = []int{num}
|
|
}
|
|
|
|
// Install package
|
|
for _, x := range numbers {
|
|
var target string
|
|
if x > numaq+numpq || x <= 0 {
|
|
continue
|
|
} else if x > numpq {
|
|
if config.SortMode == BottomUp {
|
|
target = aurQ[numaq+numpq-x].Name
|
|
} else {
|
|
target = aurQ[x-numpq-1].Name
|
|
}
|
|
if negate {
|
|
aurNI = append(aurNI, target)
|
|
} else {
|
|
aurI = append(aurI, target)
|
|
}
|
|
} else {
|
|
if config.SortMode == BottomUp {
|
|
target = repoQ[numpq-x].Name()
|
|
} else {
|
|
target = repoQ[x-1].Name()
|
|
}
|
|
if negate {
|
|
repoNI = append(repoNI, target)
|
|
} else {
|
|
repoI = append(repoI, target)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(repoI) == 0 && len(aurI) == 0 &&
|
|
(len(aurNI) > 0 || len(repoNI) > 0) {
|
|
// If no package was specified, only exclusions, exclude from all the
|
|
// packages
|
|
for _, pack := range aurQ {
|
|
aurI = append(aurI, pack.Name)
|
|
}
|
|
for _, pack := range repoQ {
|
|
repoI = append(repoI, pack.Name())
|
|
}
|
|
}
|
|
aurI = removeListFromList(aurNI, aurI)
|
|
repoI = removeListFromList(repoNI, repoI)
|
|
|
|
if len(repoI) != 0 {
|
|
err = passToPacman("-S", repoI, flags)
|
|
}
|
|
|
|
if len(aurI) != 0 {
|
|
err = aurInstall(aurI, flags)
|
|
}
|
|
|
|
return err
|
|
}
|
|
|
|
// Complete provides completion info for shells
|
|
func complete() error {
|
|
path := completionFile + config.Shell + ".cache"
|
|
info, err := os.Stat(path)
|
|
if os.IsNotExist(err) || time.Since(info.ModTime()).Hours() > 48 {
|
|
os.MkdirAll(filepath.Dir(completionFile), 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
|
|
}
|
|
|
|
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
|
|
}
|