import options, os, re, sequtils, sets, strutils, sugar, tables, lc, utils, "wrapper/alpm" type ConstraintOperation* {.pure.} = enum ge = ">=", gt = ">", eq = "=", lt = "<", le = "<=" VersionConstraint* = tuple[ operation: ConstraintOperation, version: string, impliedVersion: bool ] PackageReference* = tuple[ name: string, description: Option[string], constraint: Option[VersionConstraint] ] RpcPackageInfo* = tuple[ repo: string, base: string, name: string, version: string, description: Option[string], maintainer: Option[string], firstSubmitted: Option[int64], lastModified: Option[int64], outOfDate: Option[int64], votes: int, popularity: float, gitUrl: string, gitSubdir: Option[string] ] PackageInfo* = tuple[ rpc: RpcPackageInfo, baseIndex: int, baseCount: int, archs: seq[string], url: Option[string], licenses: seq[string], groups: seq[string], pgpKeys: seq[string], depends: seq[PackageReference], makeDepends: seq[PackageReference], checkDepends: seq[PackageReference], optional: seq[PackageReference], provides: seq[PackageReference], conflicts: seq[PackageReference], replaces: seq[PackageReference] ] GitRepo* = tuple[ url: string, bareName: Option[string], branch: Option[string], path: string ] PackageRepo = tuple[ os: HashSet[string], repo: HashSet[string], git: GitRepo ] SrcInfoPair = tuple[key: string, value: string] const packageRepos: seq[PackageRepo] = @[ (["arch", "parabola"].toHashSet, ["core", "extra", "testing"].toHashSet, ("https://git.archlinux.org/svntogit/packages.git", none(string), some("packages/${BASE}"), "repos/${REPO}-${ARCH}")), (["arch", "parabola"].toHashSet, ["community", "community-testing", "multilib", "multilib-testing"].toHashSet, ("https://git.archlinux.org/svntogit/community.git", none(string), some("packages/${BASE}"), "repos/${REPO}-${ARCH}")), (["parabola"].toHashSet, ["libre", "libre-testing", "libre-multilib", "libre-multilib-testing", "nonprism", "nonprism-testing", "nonprism-multilib", "nonprism-multilib-testing", "pcr", "pcr-testing", "pcr-multilib", "pcr-multilib-testing"].toHashSet, ("https://git.parabola.nu/abslibre.git", some("parabola"), none(string), "${REPO}/${BASE}")) ] static: # test only single match available let osSet = lc[x | (r <- packageRepos, x <- r.os), string].toHashSet let repoSet = lc[x | (r <- packageRepos, x <- r.repo), string].toHashSet for os in osSet: for repo in repoSet: let osValue = os let repoValue = repo if packageRepos.filter(pr => osValue in pr.os and repoValue in pr.repo).len >= 2: raise newException(CatchableError, "only single matching repo available: " & os & ":" & repo) # test unique url <> bareName links let bareNameToUrl = lc[(x, r.git.url) | (r <- packageRepos, x <- r.git.bareName), (string, string)].toTable let urlToBareName = lc[(r.git.url, x) | (r <- packageRepos, x <- r.git.bareName), (string, string)].toTable template testBareNamesAndUrls(m1: untyped, m2: untyped) = for x1, x2 in m1: try: if m2[x2] != x1: raise newException(CatchableError, "") except: raise newException(CatchableError, "Invalid url <> bareName links") testBareNamesAndUrls(bareNameToUrl, urlToBareName) testBareNamesAndUrls(urlToBareName, bareNameToUrl) proc readOsId: Option[string] = var file: File if file.open("/usr/lib/os-release"): try: while true: let rawLine = readLine(file) if rawLine[0 .. 2] == "ID=": return some(rawLine[3 .. ^1]) except EOFError: discard except IOError: discard finally: file.close() return none(string) let osId = readOsId() proc lookupGitRepo*(repo: string, base: string, arch: string): Option[GitRepo] = proc replaceAll(gitPart: string): string = gitPart .replace("${REPO}", repo) .replace("${BASE}", base) .replace("${ARCH}", arch) packageRepos .filter(pr => osId.isSome and osid.unsafeGet in pr.os and repo in pr.repo) .map(pr => (pr.git.url.replaceAll, pr.git.bareName, pr.git.branch.map(replaceAll), pr.git.path.replaceAll)) .optFirst template repoPath*(tmpRoot: string, base: string): string = tmpRoot & "/" & base template buildPath*(repoPath: string, gitSubdir: Option[string]): string = gitSubdir.map(p => repoPath & "/" & p).get(repoPath) template allDepends*(pkgInfo: PackageInfo): seq[PackageReference] = pkgInfo.depends & pkgInfo.makeDepends & pkgInfo.checkDepends proc checkConstraints(lop: ConstraintOperation, rop: ConstraintOperation, cmp: int): bool = let (x1, x2) = if cmp > 0: (1, -1) elif cmp < 0: (-1, 1) else: (0, 0) proc c(op: ConstraintOperation, x1: int, x2: int): bool = case op: of ConstraintOperation.eq: x1 == x2 of ConstraintOperation.ge: x1 >= x2 of ConstraintOperation.le: x1 <= x2 of ConstraintOperation.gt: x1 > x2 of ConstraintOperation.lt: x1 < x2 template a(x: int): bool = lop.c(x, x1) and rop.c(x, x2) a(2) or a(1) or a(0) or a(-1) or a(-2) proc isProvidedBy*(package: PackageReference, by: PackageReference, checkVersions: bool): bool = if package.name == by.name: if not checkVersions or package.constraint.isNone or by.constraint.isNone: true else: let lcon = package.constraint.unsafeGet let rcon = by.constraint.unsafeGet let cmp = vercmp(lcon.version, rcon.version) checkConstraints(lcon.operation, rcon.operation, cmp) else: false proc toPackageReference*(dependency: ptr AlpmDependency): PackageReference = let op = case dependency.depmod: of AlpmDepMod.eq: some(ConstraintOperation.eq) of AlpmDepMod.ge: some(ConstraintOperation.ge) of AlpmDepMod.le: some(ConstraintOperation.le) of AlpmDepMod.gt: some(ConstraintOperation.gt) of AlpmDepMod.lt: some(ConstraintOperation.lt) else: none(ConstraintOperation) let description = if dependency.desc != nil: some($dependency.desc) else: none(string) ($dependency.name, description, op.map(o => (o, $dependency.version, false))) template toPackageReference*(pkg: ptr AlpmPackage): PackageReference = ($pkg.name, none(string), some((ConstraintOperation.eq, $pkg.version, false))) template toPackageReference*(pkg: RpcPackageInfo): PackageReference = (pkg.name, none(string), some((ConstraintOperation.eq, pkg.version, false))) proc parsePackageReference*(name: string, withDescription: bool): PackageReference = var matches: array[3, string] let descIndex = name.find(": ") let (description, workName) = if withDescription and descIndex >= 0: (some(name[descIndex + 2 .. ^1]), name[0 .. descIndex - 1]) else: (none(string), name) if workName.match(re"([^><=]*)\ *(=|>=|<=|>|<)\ *([^ ]*)", matches): let constraints = toSeq(enumerate[ConstraintOperation]()) let index = constraints.map(s => $s).find(matches[1]) if index >= 0: (matches[0], description, some((constraints[index], matches[2], false))) else: (matches[0], description, none(VersionConstraint)) else: (workName, description, none(VersionConstraint)) proc parseSrcInfoKeys(srcInfo: string): tuple[baseSeq: ref seq[SrcInfoPair], table: OrderedTable[string, ref seq[SrcInfoPair]]] = var table = initOrderedTable[string, ref seq[SrcInfoPair]]() var matches: array[2, string] var baseSeq: ref seq[SrcInfoPair] var values: ref seq[SrcInfoPair] new(baseSeq) baseSeq[] = newSeq[SrcInfoPair]() for line in srcInfo.splitLines: if line.match(re"[\t\ ]*(\w+)\ =\ (.*)", matches): let key = matches[0] let value = matches[1] if key == "pkgbase": values = baseSeq elif key == "pkgname": if table.hasKey(value): values = table[value] else: new(values) values[] = newSeq[SrcInfoPair]() table[value] = values if values != nil: values[] &= (key: key, value: value) (baseSeq: baseSeq, table: table) proc parseSrcInfoName(repo: string, name: string, baseIndex: int, baseCount: int, rpcInfos: seq[RpcPackageInfo], baseSeq: ref seq[SrcInfoPair], nameSeq: ref seq[SrcInfoPair], arch: string, gitUrl: string, gitSubdir: Option[string]): Option[PackageInfo] = proc collectFromPairs(pairs: seq[SrcInfoPair], keyName: string): seq[string] = lc[x.value | (x <- pairs, x.key == keyName), string] proc collect(baseOnly: bool, keyName: string): seq[string] = let res = if baseOnly: @[] else: collectFromPairs(nameSeq[], keyName) if res.len == 0: collectFromPairs(baseSeq[], keyName).filter(x => x.len > 0) else: res.filter(x => x.len > 0) proc collectArch(baseOnly: bool, keyName: string): seq[PackageReference] = (collect(baseOnly, keyName) & collect(baseOnly, keyName & "_" & arch)) .map(n => parsePackageReference(n, true)) .filter(c => c.name.len > 0) proc filterReferences(references: seq[PackageReference], filterWith: seq[PackageReference]): seq[PackageReference] = references.filter(r => filterWith.filter(w => r.isProvidedBy(w, true)).len == 0) let base = lc[x.value | (x <- baseSeq[], x.key == "pkgbase"), string].optLast let version = collect(true, "pkgver").optLast let release = collect(true, "pkgrel").optLast let epoch = collect(true, "epoch").optLast let versionFull = lc[(v & "-" & r) | (v <- version, r <- release), string].optLast .map(v => epoch.map(e => e & ":" & v).get(v)) let description = collect(false, "pkgdesc").optLast let archs = collect(false, "arch").filter(a => a != "any") let url = collect(false, "url").optLast let licenses = collect(false, "license") let groups = collect(false, "groups") let pgpKeys = collect(true, "validpgpkeys") let baseDepends = collectArch(true, "depends") let depends = collectArch(false, "depends") let makeDepends = (baseDepends & collectArch(true, "makedepends")) .deduplicate.filterReferences(depends) let checkDepends = collectArch(true, "checkdepends") .filterReferences(depends & makeDepends) let optional = collectArch(false, "optdepends") let provides = collectArch(false, "provides") let conflicts = collectArch(false, "conflicts") let replaces = collectArch(false, "replaces") let info = rpcInfos.filter(i => i.name == name).optLast lc[((repo, b, name, v, description, info.map(i => i.maintainer).flatten, info.map(i => i.firstSubmitted).flatten, info.map(i => i.lastModified).flatten, info.map(i => i.outOfDate).flatten, info.map(i => i.votes).get(0), info.map(i => i.popularity).get(0), gitUrl, gitSubdir), baseIndex, baseCount, archs, url, licenses, groups, pgpKeys, depends, makeDepends, checkDepends, optional, provides, conflicts, replaces) | (b <- base, v <- versionFull), PackageInfo].optLast proc parseSrcInfo*(repo: string, srcInfo: string, arch: string, gitUrl: string, gitSubdir: Option[string], rpcInfos: seq[RpcPackageInfo] = @[]): seq[PackageInfo] = let parsed = parseSrcInfoKeys(srcInfo) toSeq(parsed.table.namedPairs).foldl(a & toSeq(parseSrcInfoName(repo, b.key, a.len, parsed.table.len, rpcInfos, parsed.baseSeq, b.value, arch, gitUrl, gitSubdir).items), newSeq[PackageInfo]()) proc `$`*(reference: PackageReference): string = reference.constraint .map(c => reference.name & $c.operation & c.version) .get(reference.name)