system/yay
system/yay
1
0
Fork 0
mirror of https://github.com/Jguer/yay synced 2024-10-31 04:12:51 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #198 from Morganamilo/doc

Browse source 
Add comments, spellchecking and formatting
This commit is contained in:
Morgana 2018-03-03 03:17:46 +00:00 committed by GitHub
commit 2ced41e6e6
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 121 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

106
dependencies.go
View file

@ -43,12 +43,44 @@ func makeDependCatagories() *depCatagories {
return &dc
}
// Cut the version requirement from a dependency leaving just the name.
func getNameFromDep(dep string) string {
return strings.FieldsFunc(dep, func(c rune) bool {
return c == '>' || c == '<' || c == '='
})[0]
}
// Step two of dependency resolving. We already have all the information on the
// packages we need, now it's just about ordering them correctly.
// pkgs is a list of targets, the packages we want to install. Dependencies are
// not included.
// For each package we want we iterate down the tree until we hit the bottom.
// This is done recursively for each branch.
// The start of the tree is defined as the package we want.
// When we hit the bottom of the branch we know thats the first package
// we need to install so we add it to the start of the to install
// list (dc.Aur and dc.Repo).
// We work our way up until there is another branch to go down and do it all
// again.
//
// Here is a visual example:
//
// a
// / \
// b c
// / \
// d e
//
// We see a and it needs b and c
// We see b and it needs d and e
// We see d - it needs nothing so we add d to our list and move up
// We see e - it needs nothing so we add e to our list and move up
// We see c - it needs nothing so we add c to our list and move up
//
// The final install order would come out as debca
//
// There is a little more to this, handling provides, multiple packages wanting the
// same dependencies, etc. This is just the basic premise.
func getDepCatagories(pkgs []string, dt *depTree) (*depCatagories, error) {
dc := makeDependCatagories()
seen := make(stringSet)
@ -174,6 +206,38 @@ func depCatagoriesRecursive(_pkg *rpc.Pkg, dc *depCatagories, dt *depTree, isMak
}
}
// This is step one for dependency resolving. pkgs is a slice of the packages you
// want to resolve the dependencies for. They can be a mix of aur and repo
// dependencies. All unmet dependencies will be resolved.
//
// For Aur dependencies depends, makedepends and checkdepends are resolved but
// for repo packages only depends are resolved as they are prebuilt.
// The return will be split into three catagories: Repo, Aur and Missing.
// The return is in no way ordered. This step is is just aimed at gathering the
// packages we need.
//
// This has been designed to make the least amount of rpc requests as possible.
// Web requests are probably going to be the bottleneck here so minimizing them
// provides a nice speed boost.
//
// Here is a visual expample of the request system.
// Remember only unsatisfied packages are requested, if a package is already
// installed we dont bother.
//
// a
// / \
// b c
// / \
// d e
//
// We see a so we send a request for a
// We see a wants b and c so we send a request for b and c
// We see d and e so we send a request for d and e
//
// Thats 5 packages in 3 requests. The amount of requests needed should always be
// the same as the height of the tree.
// The example does not really do this justice, In the real world where packages
// have 10+ dependencies each this is a very nice optimization.
func getDepTree(pkgs []string) (*depTree, error) {
dt := makeDepTree()
@ -187,14 +251,14 @@ func getDepTree(pkgs []string) (*depTree, error) {
}
for _, pkg := range pkgs {
//if they explicitly asked for it still look for installed pkgs
// If they explicitly asked for it still look for installed pkgs
/*installedPkg, isInstalled := localDb.PkgCache().FindSatisfier(pkg)
if isInstalled == nil {
dt.Repo[installedPkg.Name()] = installedPkg
continue
}//*/
//check the repos for a matching dep
// Check the repos for a matching dep
repoPkg, inRepos := syncDb.FindSatisfier(pkg)
if inRepos == nil {
repoTreeRecursive(repoPkg, dt, localDb, syncDb)
@ -214,9 +278,9 @@ func getDepTree(pkgs []string) (*depTree, error) {
return dt, err
}
//takes a repo package
//gives all of the non installed deps
//does again on each sub dep
// Takes a repo package,
// gives all of the non installed deps,
// repeats on each sub dep.
func repoTreeRecursive(pkg *alpm.Package, dt *depTree, localDb *alpm.Db, syncDb alpm.DbList) (err error) {
_, exists := dt.Repo[pkg.Name()]
if exists {
@ -261,76 +325,76 @@ func depTreeRecursive(dt *depTree, localDb *alpm.Db, syncDb alpm.DbList, isMake
nextProcess := make(stringSet)
currentProcess := make(stringSet)
//strip version conditions
// Strip version conditions
for dep := range dt.ToProcess {
currentProcess.set(getNameFromDep(dep))
}
//assume toprocess only contains aur stuff we have not seen
// Assume toprocess only contains aur stuff we have not seen
info, err := aurInfo(currentProcess.toSlice())
if err != nil {
return
}
//cache the results
// Cache the results
for _, pkg := range info {
//copying to p fixes a bug
//would rather not copy but cant find another way to fix
// Copying to p fixes a bug.
// Would rather not copy but cant find another way to fix.
p := pkg
dt.Aur[pkg.Name] = &p
}
//loop through to process and check if we now have
//each packaged cached
//if its not cached we assume its missing
// Loop through to process and check if we now have
// each packaged cached.
// If not cached, we assume it is missing.
for pkgName := range currentProcess {
pkg, exists := dt.Aur[pkgName]
//did not get it in the request
// Did not get it in the request.
if !exists {
dt.Missing.set(pkgName)
continue
}
//for each dep and makedep
// for each dep and makedep
for _, deps := range [3][]string{pkg.Depends, pkg.MakeDepends, pkg.CheckDepends} {
for _, versionedDep := range deps {
dep := getNameFromDep(versionedDep)
_, exists = dt.Aur[dep]
//we have it cached so skip
// We have it cached so skip.
if exists {
continue
}
_, exists = dt.Repo[dep]
//we have it cached so skip
// We have it cached so skip.
if exists {
continue
}
_, exists = dt.Missing[dep]
//we know it does not resolve so skip
// We know it does not resolve so skip.
if exists {
continue
}
//check if already installed
// Check if already installed.
_, isInstalled := localDb.PkgCache().FindSatisfier(versionedDep)
if isInstalled == nil {
continue
}
//check the repos for a matching dep
// Check the repos for a matching dep.
repoPkg, inRepos := syncDb.FindSatisfier(versionedDep)
if inRepos == nil {
repoTreeRecursive(repoPkg, dt, localDb, syncDb)
continue
}
//if all else fails add it to next search
// If all else fails add it to next search.
nextProcess.set(versionedDep)
}
}

26
parser.go
View file

@ -7,6 +7,12 @@ import (
"strings"
)
// A basic set implementation for strings.
// This is used a lot so it deserves its own type.
// Other types of sets are used throughout the code but do not have
// their own typedef.
// String sets and <type>sets should be used throughout the code when applicable,
// they are a lot more flexable than slices and provide easy lookup.
type stringSet map[string]struct{}
func (set stringSet) set(v string) {
@ -32,11 +38,13 @@ func (set stringSet) toSlice() []string {
return slice
}
// Parses command line arguments in a way we can interact with programmatically but
// also in a way that can easily be passed to pacman later on.
type arguments struct {
op string
options map[string]string
globals map[string]string
doubles stringSet //tracks args passed twice such as -yy and -dd
doubles stringSet // Tracks args passed twice such as -yy and -dd
targets stringSet
}
@ -127,7 +135,7 @@ func (parser *arguments) needRoot() bool {
case "U", "upgrade":
return true
//yay specific
// yay specific
case "Y", "yay":
return false
case "P", "print":
@ -177,7 +185,7 @@ func (parser *arguments) addArg(options ...string) (err error) {
return
}
//multiple args acts as an OR operator
// Multiple args acts as an OR operator
func (parser *arguments) existsArg(options ...string) bool {
for _, option := range options {
_, exists := parser.options[option]
@ -225,7 +233,7 @@ func (parser *arguments) delTarget(targets ...string) {
}
}
//multiple args acts as an OR operator
// Multiple args acts as an OR operator
func (parser *arguments) existsDouble(options ...string) bool {
for _, option := range options {
_, exists := parser.doubles[option]
@ -321,7 +329,7 @@ func isOp(op string) bool {
case "U", "upgrade":
return true
//yay specific
// yay specific
case "Y", "yay":
return true
case "P", "print":
@ -405,8 +413,8 @@ func hasParam(arg string) bool {
}
}
//parses short hand options such as:
//-Syu -b/some/path -
// Parses short hand options such as:
// -Syu -b/some/path -
func (parser *arguments) parseShortOption(arg string, param string) (usedNext bool, err error) {
if arg == "-" {
err = parser.addArg("-")
@ -439,8 +447,8 @@ func (parser *arguments) parseShortOption(arg string, param string) (usedNext bo
return
}
//parses full length options such as:
//--sync --refresh --sysupgrade --dbpath /some/path --
// Parses full length options such as:
// --sync --refresh --sysupgrade --dbpath /some/path --
func (parser *arguments) parseLongOption(arg string, param string) (usedNext bool, err error) {
if arg == "--" {
err = parser.addArg(arg)

20
print.go
View file

@ -13,7 +13,7 @@ import (
const arrow = "==>"
// Human returns results in Human readable format.
// human method returns results in human readable format.
func human(size int64) string {
floatsize := float32(size)
units := [...]string{"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi"}
@ -64,7 +64,7 @@ func (q aurQuery) printSearch(start int) {
}
}
//PrintSearch receives a RepoSearch type and outputs pretty text.
// PrintSearch receives a RepoSearch type and outputs pretty text.
func (s repoQuery) printSearch() {
for i, res := range s {
var toprint string
@ -100,6 +100,9 @@ func (s repoQuery) printSearch() {
}
}
// Pretty print a set of packages from the same package base.
// Packages foo and bar from a pkgbase named base would print like so:
// base (foo bar)
func formatPkgbase(pkg *rpc.Pkg, bases map[string][]*rpc.Pkg) string {
str := pkg.PackageBase
if len(bases[pkg.PackageBase]) > 1 || pkg.PackageBase != pkg.Name {
@ -265,7 +268,7 @@ func localStatistics() error {
return nil
}
//todo make it less hacky
//TODO: Make it less hacky
func printNumberOfUpdates() error {
//todo
old := os.Stdout // keep backup of the real stdout
@ -282,15 +285,15 @@ func printNumberOfUpdates() error {
return nil
}
//todo make it less hacky
//TODO: Make it less hacky
func printUpdateList() error {
old := os.Stdout // keep backup of the real stdout
old := os.Stdout // Keep backup of the real stdout
os.Stdout = nil
_, _, localNames, remoteNames, err := filterPackages()
dt, _ := getDepTree(append(localNames, remoteNames...))
aurUp, repoUp, err := upList(dt)
os.Stdout = old // restoring the real stdout
os.Stdout = old // Restoring the real stdout
if err != nil {
return err
}
@ -305,9 +308,10 @@ func printUpdateList() error {
return nil
}
// Formats a unix timestamp to yyyy/mm/dd
func formatTime(i int) string {
t := time.Unix(int64(i), 0)
return fmt.Sprintf("%d/%d/%d", t.Year(), int(t.Month()), t.Day())
return fmt.Sprintf("%d/%02d/%02d", t.Year(), int(t.Month()), t.Day())
}
func red(in string) string {
@ -366,6 +370,8 @@ func bold(in string) string {
return in
}
// Colours text using a hashing algorithm. The same text will always produce the
// same colour while different text will produce a different colour.
func colourHash(name string) (output string) {
if alpmConf.Options&alpm.ConfColor == 0 {
return name

7
query.go
View file

@ -150,7 +150,7 @@ func syncInfo(pkgS []string) (err error) {
}
}
//repo always goes first
// Repo always goes first
if len(repoS) != 0 {
arguments := cmdArgs.copy()
arguments.delTarget(aurS...)
@ -317,6 +317,11 @@ func min(a, b int) int {
return a
}
// Queries the aur for information about specified packages.
// All packages should be queried in a single rpc request except when the number
// of packages exceeds the number set in config.RequestSplitN.
// If the number does exceed config.RequestSplitN multiple rpc requests will be
// performed concurrently.
func aurInfo(names []string) ([]rpc.Pkg, error) {
info := make([]rpc.Pkg, 0, len(names))
seen := make(map[string]int)