diff options
| -rw-r--r-- | src/args.nim | 33 | ||||
| -rw-r--r-- | src/aur.nim | 80 | ||||
| -rw-r--r-- | src/common.nim | 78 | ||||
| -rw-r--r-- | src/feature/syncinfo.nim | 13 | ||||
| -rw-r--r-- | src/feature/syncinstall.nim | 270 | ||||
| -rw-r--r-- | src/format.nim | 11 | ||||
| -rw-r--r-- | src/main.nim | 15 | ||||
| -rw-r--r-- | src/package.nim | 108 | ||||
| -rw-r--r-- | src/pacman.nim | 121 |
9 files changed, 265 insertions, 464 deletions
diff --git a/src/args.nim b/src/args.nim index b93d5fb..cd778f6 100644 --- a/src/args.nim +++ b/src/args.nim @@ -104,13 +104,10 @@ proc splitArgs*(params: seq[string], let argsResult = toSeq(splitSingle(current[1 .. ^1], optionsWithParameter, next)) let consumedNext = argsResult.map(a => a.consumedNext).foldl(a or b) let newNext = next.filter(n => not consumedNext) - when NimVersion >= "1.2": - return((block:collect(newSeq): - for x in argsResult: - (x.key,x.value,ArgumentType.short) - ), newNext, stdinConsumed, false) - else: - return (lc[(x.key, x.value, ArgumentType.short) | (x <- argsResult), Argument], newNext, stdinConsumed, false) + return((block:collect(newSeq): + for x in argsResult: + (x.key,x.value,ArgumentType.short) + ), newNext, stdinConsumed, false) else: return (@[(current, none(string), ArgumentType.target)], next, stdinConsumed, false) @@ -143,13 +140,10 @@ proc splitArgs*(params: seq[string], discard close(0) discard open("/dev/tty", O_RDONLY) - when NimVersion >= "1.2": - collect(newSeq): - for y in cycle.args: - for x in y.arg: - x - else: - lc[x | (y <- cycle.args, x <- y.arg), Argument] + collect(newSeq): + for y in cycle.args: + for x in y.arg: + x proc isShort*(arg: Argument): bool = arg.atype == ArgumentType.short proc isLong*(arg: Argument): bool = arg.atype == ArgumentType.long @@ -178,13 +172,10 @@ iterator items*(op: OptionPair): OptionKey = proc filter*(args: seq[Argument], removeMatches: bool, keepTargets: bool, pairs: varargs[OptionPair]): seq[Argument] = let pairsSeq = @pairs - when NimVersion >= "1.2": - let argsSet = collect(initHashSet): - for y in pairsSeq: - for x in y: - {x} - else: - let argsSet = lc[x | (y <- pairsSeq, x <- y), OptionKey].toHashSet + let argsSet = collect(initHashSet): + for y in pairsSeq: + for x in y: + {x} args.filter(arg => (arg.isShort and (removeMatches xor (arg.key, false) in argsSet)) or (arg.isLong and (removeMatches xor (arg.key, true) in argsSet)) or (arg.isTarget and keepTargets)) diff --git a/src/aur.nim b/src/aur.nim index 542a21c..8f555cb 100644 --- a/src/aur.nim +++ b/src/aur.nim @@ -70,21 +70,16 @@ proc getRpcPackageInfos*(pkgs: seq[string], repo: string, useTimeout: bool): .foldl(a & "&arg[]=" & b) performString(url, useTimeout))) - when NimVersion >= "1.2": - let table = collect(initTable): - for z in responses: - for y in parseJson(z)["results"]: - for x in parseRpcPackageInfo(y,repo): - {x.name:x} - ((block:collect(newSeq): - for p in pkgs: - for x in table.opt(p): - x - ),none(string)) - else: - let table = lc[(x.name, x) | (z <- responses, y <- parseJson(z)["results"], - x <- parseRpcPackageInfo(y, repo)), (string, RpcPackageInfo)].toTable - (lc[x | (p <- pkgs, x <- table.opt(p)), RpcPackageInfo], none(string)) + let table = collect(initTable): + for z in responses: + for y in parseJson(z)["results"]: + for x in parseRpcPackageInfo(y,repo): + {x.name:x} + ((block:collect(newSeq): + for p in pkgs: + for x in table.opt(p): + x + ),none(string)) except CurlError: (@[], some(getCurrentException().msg)) except JsonParsingError: @@ -107,14 +102,11 @@ proc getAurPackageInfos*(pkgs: seq[string], repo: string, arch: string, useTimeo error: Option[string] ] - when NimVersion >= "1.2": - let deduplicated = deduplicate: - collect(newSeq): - for x in rpcInfos: - x.base - else: - let deduplicated = lc[x.base | (x <- rpcInfos), string].deduplicate - + let deduplicated = deduplicate: + collect(newSeq): + for x in rpcInfos: + x.base + proc obtainAndParse(base: string, index: int): ParseResult = let (srcInfo, operror) = obtainPkgBaseSrcInfo(base, useTimeout) @@ -126,27 +118,20 @@ proc getAurPackageInfos*(pkgs: seq[string], repo: string, arch: string, useTimeo (pkgInfos, none(string)) let parsed = deduplicated.foldl(a & obtainAndParse(b, a.len), newSeq[ParseResult]()) - when NimVersion >= "1.2": - let infos = collect(newSeq): - for y in parsed: - for x in y.infos: - x - let errors = collect(newSeq): - for y in parsed: - for x in y.error: - x - else: - let infos = lc[x | (y <- parsed, x <- y.infos), PackageInfo] - let errors = lc[x | (y <- parsed, x <- y.error), string] + let infos = collect(newSeq): + for y in parsed: + for x in y.infos: + x + let errors = collect(newSeq): + for y in parsed: + for x in y.error: + x let table = infos.map(i => (i.rpc.name, i)).toTable - when NimVersion >= "1.2": - let pkgInfos = collect(newSeq): - for p in pkgs: - for x in table.opt(p): - x - else: - let pkgInfos = lc[x | (p <- pkgs, x <- table.opt(p)), PackageInfo] + let pkgInfos = collect(newSeq): + for p in pkgs: + for x in table.opt(p): + x let names = rpcInfos.map(i => i.name).toHashSet let additionalPkgInfos = infos.filter(i => not (i.rpc.name in names)) @@ -166,13 +151,10 @@ proc findAurPackages*(query: seq[string], repo: string, useTimeout: bool): let response = performString(url, useTimeout) let results = parseJson(response)["results"] - when NimVersion >= "1.2": - let rpcInfos = collect(newSeq): - for y in results: - for x in parseRpcPackageInfo(y,repo): - x - else: - let rpcInfos = lc[x | (y <- results, x <- parseRpcPackageInfo(y, repo)), RpcPackageInfo] + let rpcInfos = collect(newSeq): + for y in results: + for x in parseRpcPackageInfo(y,repo): + x let filteredRpcInfos = if query.len > 1: (block: let queryLow = query[1 .. ^1].map(q => q.toLowerAscii) diff --git a/src/common.nim b/src/common.nim index 0f2804b..f7de141 100644 --- a/src/common.nim +++ b/src/common.nim @@ -153,16 +153,12 @@ proc findSyncTargets*(handle: ptr AlpmHandle, dbs: seq[ptr AlpmDatabase], return @[] else: if allowGroups and target.reference.constraint.isNone: - when NimVersion >= "1.2": - let groupRepo = optFirst: - collect(newSeq): - for d in dbs: - for g in d.groups: - if $g.name == target.reference.name: - d - else: - let groupRepo = lc[d | (d <- dbs, g <- d.groups, - $g.name == target.reference.name), ptr AlpmDatabase].optFirst + let groupRepo = optFirst: + collect(newSeq): + for d in dbs: + for g in d.groups: + if $g.name == target.reference.name: + d if groupRepo.isSome: return @[($groupRepo.unsafeGet.name, none(SyncFoundPackageInfo))] @@ -248,14 +244,10 @@ proc queryUnrequired*(handle: ptr AlpmHandle, withOptional: bool, withoutOptiona (installed, explicit.toHashSet + assumeExplicit, dependsTable, alternatives) - when NimVersion >= "1.2": - let providedBy = collect(newSeq): - for x in alternatives.namedPairs: - for y in x.value: - (reference:y,name:x.key) - else: - let providedBy = lc[(y, x.key) | (x <- alternatives.namedPairs, y <- x.value), - tuple[reference: PackageReference, name: string]] + let providedBy = collect(newSeq): + for x in alternatives.namedPairs: + for y in x.value: + (reference:y,name:x.key) proc findRequired(withOptional: bool, results: HashSet[string], check: HashSet[string]): HashSet[string] = @@ -273,7 +265,7 @@ proc queryUnrequired*(handle: ptr AlpmHandle, withOptional: bool, withoutOptiona for x in providedBy: if y.isProvidedBy(x.reference, true): {x.name} - elif NimVersion >= "1.2": + else: let direct = block: var tmp = newSeq[PackageReference]() for y in dependsTable.namedPairs: @@ -289,11 +281,6 @@ proc queryUnrequired*(handle: ptr AlpmHandle, withOptional: bool, withoutOptiona if y.isProvidedBy(x.reference, true): tmp.incl(x.name) tmp - else: - let direct = lc[x.reference | (y <- dependsTable.namedPairs, y.key in check, - x <- y.value, withOptional or not x.optional), PackageReference] - let indirect = lc[x.name | (y <- direct, x <- providedBy, - y.isProvidedBy(x.reference, true)), string].toHashSet let checkNext = (direct.map(p => p.name).toHashSet + indirect) - full if checkNext.len > 0: findRequired(withOptional, full, checkNext) else: full @@ -664,29 +651,21 @@ proc obtainBuildPkgInfosInternal(config: Config, bases: seq[LookupBaseGroup], (list[tuple[pkgInfos: seq[PackageInfo], path: Option[string]]](), 0)) let pkgInfosWithPaths = pkgInfosWithPathsReversed.reversed - when NimVersion >= "1.2": - let pkgInfos = collect(newSeq): - for y in pkgInfosWithPaths: - for x in y.pkgInfos: - x - let paths = collect(newSeq): - for y in pkgInfosWithPaths: - for x in y.path: - x - else: - let pkgInfos = lc[x | (y <- pkgInfosWithPaths, x <- y.pkgInfos), PackageInfo] - let paths = lc[x | (y <- pkgInfosWithPaths, x <- y.path), string] + let pkgInfos = collect(newSeq): + for y in pkgInfosWithPaths: + for x in y.pkgInfos: + x + let paths = collect(newSeq): + for y in pkgInfosWithPaths: + for x in y.path: + x let pkgInfosTable = pkgInfos.map(i => (i.rpc.name, i)).toTable - when NimVersion >= "1.2": - let foundPkgInfos = collect(newSeq): - for y in pacmanTargetNames: - for x in pkgInfosTable.opt(y): - x - else: - let foundPkgInfos = lc[x | (y <- pacmanTargetNames, - x <- pkgInfosTable.opt(y)), PackageInfo] + let foundPkgInfos = collect(newSeq): + for y in pacmanTargetNames: + for x in pkgInfosTable.opt(y): + x let errorMessages = pacmanTargetNames .filter(n => not pkgInfosTable.hasKey(n)) .map(n => tr"$#: failed to get package info" % [n]) @@ -796,13 +775,10 @@ proc cloneAurReposWithPackageInfos*(config: Config, rpcInfos: seq[RpcPackageInfo let (fullPkgInfos, paths, errors) = cloneNext(0, nil, nil, nil) let pkgInfosTable = fullPkgInfos.map(i => (i.rpc.name, i)).toTable - when NimVersion >= "1.2": - let resultPkgInfos = collect(newSeq): - for y in rpcInfos: - for x in pkgInfosTable.opt(y.name): - x - else: - let resultPkgInfos = lc[x | (y <- rpcInfos, x <- pkgInfosTable.opt(y.name)), PackageInfo] + let resultPkgInfos = collect(newSeq): + for y in rpcInfos: + for x in pkgInfosTable.opt(y.name): + x let names = rpcInfos.map(i => i.name).toHashSet let additionalPkgInfos = fullPkgInfos.filter(i => not (i.rpc.name in names)) diff --git a/src/feature/syncinfo.nim b/src/feature/syncinfo.nim index 6b2278d..6f8dda9 100644 --- a/src/feature/syncinfo.nim +++ b/src/feature/syncinfo.nim @@ -131,13 +131,8 @@ proc handleSyncInfo*(args: seq[Argument], config: Config): int = let padding = pacmanInfoStrings.map(s => s.trp).computeMaxLength let pkgInfosTable = pkgInfos.map(i => (i.rpc.toPackageReference, i)).toTable - when NimVersion >= "1.2": - let codes = code & (block:collect(newSeq): - for x in fullTargets: - handleTarget(config, padding, finalArgs, x, x.rpcInfo.map(i => pkgInfosTable.opt(i.toPackageReference)).flatten) - ) - else: - let codes = code & lc[handleTarget(config, padding, finalArgs, x, - x.rpcInfo.map(i => pkgInfosTable.opt(i.toPackageReference)).flatten) | - (x <- fullTargets), int] + let codes = code & (block:collect(newSeq): + for x in fullTargets: + handleTarget(config, padding, finalArgs, x, x.rpcInfo.map(i => pkgInfosTable.opt(i.toPackageReference)).flatten) + ) codes.filter(c => c != 0).optFirst.get(0) diff --git a/src/feature/syncinstall.nim b/src/feature/syncinstall.nim index b6347f9..813eb45 100644 --- a/src/feature/syncinstall.nim +++ b/src/feature/syncinstall.nim @@ -66,14 +66,11 @@ proc isVcs(name: string): bool = proc orderInstallation(ordered: seq[seq[seq[PackageInfo]]], grouped: seq[seq[PackageInfo]], satisfied: Table[PackageReference, SatisfyResult]): seq[seq[seq[PackageInfo]]] = - when NimVersion >= "1.2": - let orderedNamesSet = collect(initHashSet): - for a in ordered: - for b in a: - for c in b: - {c.rpc.name} - else: - let orderedNamesSet = lc[c.rpc.name | (a <- ordered, b <- a, c <- b), string].toHashSet + let orderedNamesSet = collect(initHashSet): + for a in ordered: + for b in a: + for c in b: + {c.rpc.name} proc hasBuildDependency(pkgInfos: seq[PackageInfo]): bool = for pkgInfo in pkgInfos: @@ -248,17 +245,13 @@ proc findDependencies(config: Config, handle: ptr AlpmHandle, dbs: seq[ptr AlpmD success.map(r => (r.reference, r.result.unsafeGet)) & aurSuccess.map(r => (r.reference, r.result.unsafeGet))).toTable - when NimVersion >= "1.2": - let newUnsatisfied = deduplicate: - collect(newSeq): - for y in aurSuccess: - for r in y.result: - for i in r.buildPkgInfo: - for x in i.allDepends: - x - else: - let newUnsatisfied = lc[x | (y <- aurSuccess, r <- y.result, i <- r.buildPkgInfo, - x <- i.allDepends), PackageReference].deduplicate + let newUnsatisfied = deduplicate: + collect(newSeq): + for y in aurSuccess: + for r in y.result: + for i in r.buildPkgInfo: + for x in i.allDepends: + x let newTotalAurFail = (totalAurFail & aurFail).deduplicate let newTotalUnsatisfied = (newUnsatisfied & newTotalAurFail).deduplicate @@ -277,14 +270,11 @@ proc findDependencies(config: Config, handle: ptr AlpmHandle, (Table[PackageReference, SatisfyResult], seq[PackageReference], seq[string]) = let satisfied = pkgInfos.map(p => ((p.rpc.name, none(string), none(VersionConstraint)), (false, p.rpc.name, some(p)))).toTable - when NimVersion >= "1.2": - let unsatisfied = deduplicate: - collect(newSeq): - for i in pkgInfos: - for x in i.allDepends: - x - else: - let unsatisfied = lc[x | (i <- pkgInfos, x <- i.allDepends), PackageReference].deduplicate + let unsatisfied = deduplicate: + collect(newSeq): + for i in pkgInfos: + for x in i.allDepends: + x findDependencies(config, handle, dbs, satisfied, unsatisfied, @[], additionalPkgInfos, @[], nodepsCount, assumeInstalled, printMode, noaur) @@ -496,13 +486,10 @@ proc buildLoop(config: Config, pkgInfos: seq[PackageInfo], skipDeps: bool, else: resultByNames - when NimVersion >= "1.2": - let failedNames = collect(newSeq): - for x in resultByIndices: - if x.pkgInfo.isNone: - x.name - else: - let failedNames = lc[x.name | (x <- resultByIndices, x.pkgInfo.isNone), string] + let failedNames = collect(newSeq): + for x in resultByIndices: + if x.pkgInfo.isNone: + x.name if failedNames.len > 0: for name in failedNames: @@ -592,24 +579,16 @@ proc installGroupFromSources(config: Config, commonArgs: seq[Argument], let arch = if pkgInfo.archs.len > 0: config.common.arch else: "any" config.tmpRootInitial & "/" & pkgInfo.rpc.name & "-" & pkgInfo.rpc.version & "-" & arch & ext - when NimVersion >= "1.2": - let allFiles = collect(newSeq): - for br in buildResults: - for r in br.replacePkgInfos: - (name:r.name, file:formatArchiveFile(r.pkgInfo, br.ext)) - else: - let allFiles = lc[(r.name, formatArchiveFile(r.pkgInfo, br.ext)) | - (br <- buildResults, r <- br.replacePkgInfos), tuple[name: Option[string], file: string]] + let allFiles = collect(newSeq): + for br in buildResults: + for r in br.replacePkgInfos: + (name:r.name, file:formatArchiveFile(r.pkgInfo, br.ext)) let filesTable = allFiles.filter(f => f.name.isSome).map(f => (f.name.unsafeGet, f.file)).toTable - when NimVersion >= "1.2": - let install = collect(newSeq): - for g in basePackages: - for i in g: - for x in filesTable.opt(i.rpc.name): - (name:i.rpc.name,file:x) - else: - let install = lc[(i.rpc.name, x) | (g <- basePackages, i <- g, x <- filesTable.opt(i.rpc.name)), - tuple[name: string, file: string]] + let install = collect(newSeq): + for g in basePackages: + for i in g: + for x in filesTable.opt(i.rpc.name): + (name:i.rpc.name,file:x) proc handleTmpRoot(clear: bool) = let installFiles = install.map(p => p.file) @@ -670,22 +649,15 @@ proc installGroupFromSources(config: Config, commonArgs: seq[Argument], let pacmanDatabaseParams = pacmanCmd & pacmanParams(config.color, commonArgs.keepOnlyOptions(commonOptions) & ("D", none(string), ArgumentType.short)) - when NimVersion >= "1.2": - let installParams = sudoPrefix & (pkgLibDir & "/install") & - cacheDir & $cacheUser & $cacheGroup & - $pacmanUpgradeParams.len & pacmanUpgradeParams & - $pacmanDatabaseParams.len & pacmanDatabaseParams & - (block:collect(newSeq): - for i in installWithReason: - for x in [i.name,i.file,i.mode]: - x - ) - else: - let installParams = sudoPrefix & (pkgLibDir & "/install") & - cacheDir & $cacheUser & $cacheGroup & - $pacmanUpgradeParams.len & pacmanUpgradeParams & - $pacmanDatabaseParams.len & pacmanDatabaseParams & - lc[x | (i <- installWithReason, x <- [i.name, i.file, i.mode]), string] + let installParams = sudoPrefix & (pkgLibDir & "/install") & + cacheDir & $cacheUser & $cacheGroup & + $pacmanUpgradeParams.len & pacmanUpgradeParams & + $pacmanDatabaseParams.len & pacmanDatabaseParams & + (block:collect(newSeq): + for i in installWithReason: + for x in [i.name,i.file,i.mode]: + x + ) let code = forkWait(() => execResult(installParams)) if code != 0: @@ -715,15 +687,11 @@ proc installGroupFromSources(config: Config, commonArgs: seq[Argument], run(gitCmd, "-C", bareRepoPath, "tag", tag) handleTmpRoot(true) - when NimVersion >= "1.2": - let installedAs = collect(newSeq): - for br in buildResults: - for r in br.replacePkgInfos: - if r.name.isSome: - (r.name.unsafeGet, r.pkgInfo.rpc.name) - else: - let installedAs = lc[(r.name.unsafeGet, r.pkgInfo.rpc.name) | (br <- buildResults, - r <- br.replacePkgInfos, r.name.isSome), (string, string)] + let installedAs = collect(newSeq): + for br in buildResults: + for r in br.replacePkgInfos: + if r.name.isSome: + (r.name.unsafeGet, r.pkgInfo.rpc.name) (installedAs, 0) proc deduplicatePkgInfos(pkgInfos: seq[PackageInfo], @@ -755,24 +723,16 @@ proc resolveDependencies(config: Config, pkgInfos: seq[PackageInfo], newSeq[seq[seq[PackageInfo]]](), newSeq[string]()) else: let buildAndAurNamesSet = pkgInfos.map(i => i.rpc.name).toHashSet - when NimVersion >= "1.2": - let fullPkgInfos = (pkgInfos & (block:collect(newSeq): - for s in satisfied.values: - for i in s.buildPkgInfo: - if not (i.rpc.name in buildAndAurNamesSet): - i - )).deduplicatePkgInfos(config,false) - let additionalPacmanTargets = collect(newSeq): - for x in satisfied.values: - if not x.installed and x.buildPkgInfo.isNone: - x.name - else: - let fullPkgInfos = (pkgInfos & lc[i | (s <- satisfied.values, - i <- s.buildPkgInfo, not (i.rpc.name in buildAndAurNamesSet)), PackageInfo]) - .deduplicatePkgInfos(config, false) - - let additionalPacmanTargets = lc[x.name | (x <- satisfied.values, - not x.installed and x.buildPkgInfo.isNone), string] + let fullPkgInfos = (pkgInfos & (block:collect(newSeq): + for s in satisfied.values: + for i in s.buildPkgInfo: + if not (i.rpc.name in buildAndAurNamesSet): + i + )).deduplicatePkgInfos(config,false) + let additionalPacmanTargets = collect(newSeq): + for x in satisfied.values: + if not x.installed and x.buildPkgInfo.isNone: + x.name let orderedPkgInfos = orderInstallation(fullPkgInfos, satisfied) (true, satisfied, additionalPacmanTargets, orderedPkgInfos, paths) @@ -781,29 +741,20 @@ proc confirmViewAndImportKeys(config: Config, basePackages: seq[seq[seq[PackageI installed: seq[Installed], noconfirm: bool): int = if basePackages.len > 0: (block: let installedVersions = installed.map(i => (i.name, i.version)).toTable - when NimVersion >= "1.2": - printPackages(config.color, config.common.verbosePkgLists,(block:collect(newSeq): - for g in basePackages: - for b in g: - for i in b: - (i.rpc.name,i.rpc.repo,installedVersions.opt(i.rpc.name),i.rpc.version).PackageInstallFormat - ).sorted((a,b) => cmp(a.name, b.name))) - else: - printPackages(config.color, config.common.verbosePkgLists, - lc[(i.rpc.name, i.rpc.repo, installedVersions.opt(i.rpc.name), i.rpc.version) | - (g <- basePackages, b <- g, i <- b), PackageInstallFormat] - .sorted((a, b) => cmp(a.name, b.name))) + printPackages(config.color, config.common.verbosePkgLists,(block:collect(newSeq): + for g in basePackages: + for b in g: + for i in b: + (i.rpc.name,i.rpc.repo,installedVersions.opt(i.rpc.name),i.rpc.version).PackageInstallFormat + ).sorted((a,b) => cmp(a.name, b.name))) let input = printColonUserChoice(config.color, tr"Proceed with building?", ['y', 'n'], 'y', 'n', noconfirm, 'y') if input == 'y': - when NimVersion >= "1.2": - let flatBasePackages = collect(newSeq): - for a in basePackages: - for x in a: - x - else: - let flatBasePackages = lc[x | (a <- basePackages, x <- a), seq[PackageInfo]] + let flatBasePackages = collect(newSeq): + for a in basePackages: + for x in a: + x proc checkNext(index: int, skipEdit: bool, skipKeys: bool): int = if index < flatBasePackages.len: @@ -834,14 +785,11 @@ proc confirmViewAndImportKeys(config: Config, basePackages: seq[seq[seq[PackageI else: let resultPkgInfos = reloadPkgInfos(config, repoPath & "/" & pkgInfos[0].rpc.gitSubdir.get("."), pkgInfos) - when NimVersion >= "1.2": - let pgpKeys = deduplicate: - collect(newSeq): - for p in resultPkgInfos: - for x in p.pgpKeys: - x - else: - let pgpKeys = lc[x | (p <- resultPkgInfos, x <- p.pgpKeys), string].deduplicate + let pgpKeys = deduplicate: + collect(newSeq): + for p in resultPkgInfos: + for x in p.pgpKeys: + x proc keysLoop(index: int, skipKeys: bool): char = if index >= pgpKeys.len: @@ -982,14 +930,10 @@ proc filterIgnoresAndConflicts(config: Config, pkgInfos: seq[PackageInfo], targetNamesSet: HashSet[string], installed: Table[string, Installed], printMode: bool, noconfirm: bool): (seq[PackageInfo], seq[PackageInfo]) = let acceptedPkgInfos = pkgInfos.filter(pkgInfo => (block: - when NimVersion >= "1.2": - let instGroups = collect(newSeq): - for i in installed.opt(pkgInfo.rpc.name): - for x in i.groups: - x - else: - let instGroups = lc[x | (i <- installed.opt(pkgInfo.rpc.name), - x <- i.groups), string] + let instGroups = collect(newSeq): + for i in installed.opt(pkgInfo.rpc.name): + for x in i.groups: + x if config.ignored(pkgInfo.rpc.name, (instGroups & pkgInfo.groups).deduplicate): if pkgInfo.rpc.name in targetNamesSet: @@ -1006,26 +950,20 @@ proc filterIgnoresAndConflicts(config: Config, pkgInfos: seq[PackageInfo], true)) let nonConflicingPkgInfos = acceptedPkgInfos.foldl(block: - when NimVersion >= "1.2": - let conflictsWith = collect(newSeq): - for p in a: - if p.rpc.name != b.rpc.name and - (block:collect(newSeq): - for c in b.conflicts: - if c.isProvidedBy(p.rpc.toPackageReference, true): - 0 - ).len>0 or - (block:collect(newSeq): - for c in p.conflicts: - if c.isProvidedBy(p.rpc.toPackageReference, true): - 0 - ).len>0: - p - else: - let conflictsWith = lc[p | (p <- a, p.rpc.name != b.rpc.name and - (lc[0 | (c <- b.conflicts, c.isProvidedBy(p.rpc.toPackageReference, true)), int].len > 0 or - lc[0 | (c <- p.conflicts, c.isProvidedBy(b.rpc.toPackageReference, true)), int].len > 0)), - PackageInfo] + let conflictsWith = collect(newSeq): + for p in a: + if p.rpc.name != b.rpc.name and + (block:collect(newSeq): + for c in b.conflicts: + if c.isProvidedBy(p.rpc.toPackageReference, true): + 0 + ).len>0 or + (block:collect(newSeq): + for c in p.conflicts: + if c.isProvidedBy(p.rpc.toPackageReference, true): + 0 + ).len>0: + p if not printMode and conflictsWith.len > 0: for conflict in conflictsWith: printWarning(config.color, @@ -1157,12 +1095,9 @@ proc obtainInstalledWithAur(config: Config): (seq[Installed], seq[string]) = ($package.name, $package.version, package.groupsSeq, package.reason == AlpmReason.explicit, foreign) - when NimVersion >= "1.2": - let installed = collect(newSeq): - for p in handle.local.packages: - createInstalled(p) - else: - let installed = lc[createInstalled(p) | (p <- handle.local.packages), Installed] + let installed = collect(newSeq): + for p in handle.local.packages: + createInstalled(p) let checkAurUpgradeNames = installed .filter(i => i.foreign and (config.checkIgnored or not config.ignored(i.name, i.groups))) .map(i => i.name) @@ -1195,13 +1130,10 @@ proc resolveBuildTargets(config: Config, syncTargets: seq[SyncPackageTarget], let installedTable = installed.map(i => (i.name, i)).toTable let rpcAurTargets = fullTargets.filter(f => f.isAurTargetFull(config.aurRepo)) - when NimVersion >= "1.2": - let targetRpcInfos = collect(newSeq): - for t in rpcAurTargets: - for x in t.rpcInfo: - x - else: - let targetRpcInfos = lc[x | (t <- rpcAurTargets, x <- t.rpcInfo), RpcPackageInfo] + let targetRpcInfos = collect(newSeq): + for t in rpcAurTargets: + for x in t.rpcInfo: + x let targetRpcInfoNames = targetRpcInfos.map(i => i.name).toHashSet let rpcInfos = targetRpcInfos & upgradeRpcInfos.filter(i => not (i.name in targetRpcInfoNames)) @@ -1349,15 +1281,11 @@ proc handleInstall(args: seq[Argument], config: Config, syncTargets: seq[SyncPac return true return false - when NimVersion >= "1.2": - collect(newSeq): - for x in satisfied.namedPairs: - if not x.value.installed and x.value.buildPkgInfo.isNone and - not x.key.checkSatisfied: - x.key - else: - lc[x.key | (x <- satisfied.namedPairs, not x.value.installed and - x.value.buildPkgInfo.isNone and not x.key.checkSatisfied), PackageReference] + collect(newSeq): + for x in satisfied.namedPairs: + if not x.value.installed and x.value.buildPkgInfo.isNone and + not x.key.checkSatisfied: + x.key else: @[] diff --git a/src/format.nim b/src/format.nim index f4255fb..bd6d393 100644 --- a/src/format.nim +++ b/src/format.nim @@ -110,13 +110,10 @@ proc printPackageInfo*(minPadding: int, color: bool, lines: varargs[PackageLineF if values.len == 0: @[] elif forceBreak: - when NimVersion > "1.2": - collect(newSeq): - for y in values.map(s => strutils.strip(s).splitLines(lineSize)): - for x in y: - x - else: - lc[x | (y <- values.map(s => strutils.strip(s).splitLines(lineSize)), x <- y), string] + collect(newSeq): + for y in values.map(s => strutils.strip(s).splitLines(lineSize)): + for x in y: + x else: values.map(v => strutils.strip(v)).foldl(a & " " & b).splitLines(lineSize) diff --git a/src/main.nim b/src/main.nim index 458ba72..d8ad5a5 100644 --- a/src/main.nim +++ b/src/main.nim @@ -11,16 +11,11 @@ import "feature/syncsource" proc execSudo*(args: seq[Argument]): int = - when NimVersion >= "1.2": - execResult(sudoPrefix & getAppFilename() & (block:collect(newSeq): - for y in args: - for x in y.collectArg: - x - )) - else: - execResult(sudoPrefix & getAppFilename() & - lc[x | (y <- args, x <- y.collectArg), string]) - + execResult(sudoPrefix & getAppFilename() & (block:collect(newSeq): + for y in args: + for x in y.collectArg: + x + )) proc passValidation(args: seq[Argument], config: Config, nonRootArgs: openArray[OptionPair], rootArgs: openArray[OptionPair], opts: varargs[seq[CommandOption]]): int = diff --git a/src/package.nim b/src/package.nim index 3014cba..feab377 100644 --- a/src/package.nim +++ b/src/package.nim @@ -91,18 +91,14 @@ const static: # test only single match available - when NimVersion >= "1.2": - let osSet = collect(initHashSet): - for r in packageRepos: - for x in r.os: - {x} - let repoSet = collect(initHashSet): - for r in packageRepos: - for x in r.repo: - {x} - else: - let osSet = lc[x | (r <- packageRepos, x <- r.os), string].toHashSet - let repoSet = lc[x | (r <- packageRepos, x <- r.repo), string].toHashSet + let osSet = collect(initHashSet): + for r in packageRepos: + for x in r.os: + {x} + let repoSet = collect(initHashSet): + for r in packageRepos: + for x in r.repo: + {x} for os in osSet: for repo in repoSet: let osValue = os @@ -112,20 +108,14 @@ static: "only single matching repo available: " & os & ":" & repo) # test unique url <> bareName links - when NimVersion >= "1.2": - let bareNameToUrl = collect(initTable): - for r in packageRepos: - for x in r.git.bareName: - {x:r.git.url} - let urlToBareName = collect(initTable): - for r in packageRepos: - for x in r.git.bareName: - {r.git.url:x} - else: - 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 + let bareNameToUrl = collect(initTable): + for r in packageRepos: + for x in r.git.bareName: + {x:r.git.url} + let urlToBareName = collect(initTable): + for r in packageRepos: + for x in r.git.bareName: + {r.git.url:x} template testBareNamesAndUrls(m1: untyped, m2: untyped) = for x1, x2 in m1: @@ -282,13 +272,10 @@ 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] = - when NimVersion >= "1.2": - collect(newSeq): - for x in pairs: - if x.key == keyName: - x.value - else: - lc[x.value | (x <- pairs, x.key == keyName), string] + collect(newSeq): + for x in pairs: + if x.key == keyName: + x.value #changed the name as shadows collect macro from sugar proc collectName(baseOnly: bool, keyName: string): seq[string] = let res = if baseOnly: @[] else: collectFromPairs(nameSeq[], keyName) @@ -306,27 +293,20 @@ proc parseSrcInfoName(repo: string, name: string, baseIndex: int, baseCount: int filterWith: seq[PackageReference]): seq[PackageReference] = references.filter(r => filterWith.filter(w => r.isProvidedBy(w, true)).len == 0) - when NimVersion >= "1.2": - let base = optLast: - collect(newSeq): - for x in baseSeq[]: - if x.key == "pkgbase": - x.value - else: - let base = lc[x.value | (x <- baseSeq[], x.key == "pkgbase"), string].optLast + let base = optLast: + collect(newSeq): + for x in baseSeq[]: + if x.key == "pkgbase": + x.value let version = collectName(true, "pkgver").optLast let release = collectName(true, "pkgrel").optLast let epoch = collectName(true, "epoch").optLast - when NimVersion >= "1.2": - let versionFull = (block:collect(newSeq): - for v in version: - for r in release: - (v & "-" & r) - ).optLast.map(v => epoch.map(e => e & ":" & v).get(v)) - else: - let versionFull = lc[(v & "-" & r) | (v <- version, r <- release), string].optLast - .map(v => epoch.map(e => e & ":" & v).get(v)) + let versionFull = (block:collect(newSeq): + for v in version: + for r in release: + (v & "-" & r) + ).optLast.map(v => epoch.map(e => e & ":" & v).get(v)) let description = collectName(false, "pkgdesc").optLast let archs = collectName(false, "arch").filter(a => a != "any") @@ -348,24 +328,16 @@ proc parseSrcInfoName(repo: string, name: string, baseIndex: int, baseCount: int let info = rpcInfos.filter(i => i.name == name).optLast - when NimVersion >= "1.2": - optLast: - collect(newSeq): - for b in base: - for v in versionFull: - ((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) - else: - 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 + optLast: + collect(newSeq): + for b in base: + for v in versionFull: + ((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) proc parseSrcInfo*(repo: string, srcInfo: string, arch: string, gitUrl: string, gitSubdir: Option[string], rpcInfos: seq[RpcPackageInfo] = @[]): seq[PackageInfo] = diff --git a/src/pacman.nim b/src/pacman.nim index f9fc978..ed80311 100644 --- a/src/pacman.nim +++ b/src/pacman.nim @@ -36,13 +36,10 @@ proc calculateOptionsWithParameter(opts: seq[CommandOption]): seq[OptionKey] {.c else: @[] - when NimVersion >= "1.2": - collect(newSeq): - for y in opts: - for x in commandToSeq(y): - x - else: - lc[x | (y <- opts, x <- commandToSeq(y)), OptionKey] + collect(newSeq): + for y in opts: + for x in commandToSeq(y): + x proc o(long: string): CommandOption {.compileTime.} = ((none(string), long), false, false, {}) @@ -206,13 +203,10 @@ proc getOperation*(args: seq[Argument]): OperationType = proc filterOptions*(args: seq[Argument], removeMatches: bool, keepTargets: bool, includeOperations: bool, opts: varargs[seq[CommandOption]]): seq[Argument] = let optsSeq = @opts - when NimVersion >= "1.2": - let optsPairSeq = collect(newSeq): - for y in optsSeq: - for x in y: - x.pair - else: - let optsPairSeq = lc[x.pair | (y <- optsSeq, x <- y), OptionPair] + let optsPairSeq = collect(newSeq): + for y in optsSeq: + for x in y: + x.pair let work = if includeOperations: (optsPairSeq & operations.map(o => o.pair)) @@ -246,45 +240,30 @@ proc filterExtensions*(args: seq[Argument], removeMatches: bool, keepTargets: bo opts: varargs[seq[CommandOption]]): seq[Argument] = let optsSeq = @opts let optsFilter = if removeMatches: - when NimVersion >= "1.2": - collect(newSeq): - for y in optsSeq: - for x in y: - x - else: - lc[x | (y <- optsSeq, x <- y), CommandOption] + collect(newSeq): + for y in optsSeq: + for x in y: + x else: (block: - when NimVersion >= "1.2": - let pairs = collect(initHashSet): - for y in optsSeq: - for x in y: - {x.pair} - collect(newSeq): - for x in allOptions: - if not (x.pair in pairs): - x - else: - let pairs = lc[x.pair | (y <- optsSeq, x <- y), OptionPair].toHashSet - lc[x | (x <- allOptions, not (x.pair in pairs)), CommandOption] + let pairs = collect(initHashSet): + for y in optsSeq: + for x in y: + {x.pair} + collect(newSeq): + for x in allOptions: + if not (x.pair in pairs): + x ) - - when NimVersion >= "1.2": - let argsSeq = collect(newSeq): - for x in optsFilter: - if x.extension: - x.pair - else: - let argsSeq = lc[x.pair | (x <- optsFilter, x.extension), OptionPair] - args.filter(removeMatches, keepTargets, argsSeq) - + let argsSeq = collect(newSeq): + for x in optsFilter: + if x.extension: + x.pair + args.filter(removeMatches,keepTargets,argsSeq) proc obtainConflictsPairs(conflicts: seq[ConflictingOptions]): Table[string, seq[OptionPair]] = - when NimVersion >= "1.2": - let all = collect(newSeq): - for y in conflicts: - for x in (y.left & y.right): - x - else: - let all = lc[x | (y <- conflicts, x <- y.left & y.right), string].deduplicate + let all = collect(newSeq): + for y in conflicts: + for x in (y.left & y.right): + x all.map(c => (c, allOptions.filter(o => o.pair.long == c) .map(o => o.pair).deduplicate)).toTable @@ -308,7 +287,7 @@ proc checkConflicts*(args: seq[Argument], for w in c.right: if args.check(w.full): (c.left,w) - elif NimVersion >= "1.2": + else: optFirst: var tmp = newSeq[(string,string)]() for c in conflicts: @@ -317,21 +296,15 @@ proc checkConflicts*(args: seq[Argument], if args.check(w.full): tmp.add((c.left,w)) tmp - else: - lc[(c.left, w) | (c <- conflicts, args.check(c.left.full), - w <- c.right, args.check(w.full)), (string, string)].optFirst proc pacmanParams*(color: bool, args: varargs[Argument]): seq[string] = let colorStr = if color: "always" else: "never" let argsSeq = ("color", some(colorStr), ArgumentType.long) & @args.filter(arg => not arg.matchOption(%%%"color")) - when NimVersion >= "1.2": - collect(newSeq): - for y in argsSeq: - for x in y.collectArg: - x - else: - lc[x | (y <- argsSeq, x <- y.collectArg), string] + collect(newSeq): + for y in argsSeq: + for x in y.collectArg: + x proc pacmanExecInternal(root: bool, params: varargs[string]): int = let exec = if root: sudoPrefix & pacmanCmd & @params else: pacmanCmd & @params @@ -354,7 +327,7 @@ proc pacmanValidateAndThrow(args: varargs[tuple[arg: Argument, pass: bool]]): vo if y.pass: for x in y.arg.collectArg: x - elif NimVersion >= "1.2": + else: let collectedArgs = block: var tmp = newSeq[string]() for y in argsSeq: @@ -362,8 +335,6 @@ proc pacmanValidateAndThrow(args: varargs[tuple[arg: Argument, pass: bool]]): vo for x in y.arg.collectArg: tmp.add(x) tmp - else: - let collectedArgs = lc[x | (y <- argsSeq, y.pass, x <- y.arg.collectArg), string] let code = forkWait(() => pacmanExecInternal(false, "-T" & collectedArgs)) if code != 0: raise haltError(code) @@ -426,20 +397,14 @@ proc obtainPacmanConfig*(args: seq[Argument]): PacmanConfig = let debug = args.check(%%%"debug") let progressBar = not args.check(%%%"noprogressbar") - when NimVersion >= "1.2": - let ignorePkgs = collect(initHashSet): - for y in getAll(%%%"ignore"): - for x in y.split(','): - {x} - let ignoreGroups = collect(initHashSet): - for y in getAll(%%%"ignoregroup"): - for x in y.split(','): - {x} - else: - let ignorePkgs = lc[x | (y <- getAll(%%%"ignore"), - x <- y.split(',')), string].toHashSet - let ignoreGroups = lc[x | (y <- getAll(%%%"ignoregroup"), - x <- y.split(',')), string].toHashSet + let ignorePkgs = collect(initHashSet): + for y in getAll(%%%"ignore"): + for x in y.split(','): + {x} + let ignoreGroups = collect(initHashSet): + for y in getAll(%%%"ignoregroup"): + for x in y.split(','): + {x} let hasKeyserver = forkWaitRedirect(() => (block: if dropPrivileges(): |