☰

Index

Modules: clue, clue/cli/live, clue/commands/build, clue/commands/bump, clue/commands/dbcheck, clue/commands/deploy, clue/commands/docs, clue/commands/doctor, clue/commands/init, clue/commands/manager, clue/commands/nimscript, clue/commands/publish, clue/commands/sources, clue/commands/upgrade, clue/deploy/configs, clue/deploy/dir, clue/deploy/init, clue/deploy/releases, clue/deploy/remotes, clue/deploy/web, clue/docbuilder/builder, clue/docbuilder/configs, clue/docbuilder/httpserver, clue/docbuilder/overviewgen, clue/pkgmanager/builder, clue/pkgmanager/configs, clue/pkgmanager/lockfile, clue/pkgmanager/nimbleparser, clue/pkgmanager/resolver, clue/pkgmanager/versions.

API symbols

allInstalledPaths:

versions: proc allInstalledPaths(): seq[string]

applySshpassEnv:

remotes: proc applySshpassEnv(auth: RemoteAuth)

buildCommand:

build: proc buildCommand(v: Values)

buildDeployYaml:

init: proc buildDeployYaml(project, deployType, version, host, user, remoteDir: string; releaseRepo = ""): string

builder: proc buildDocs(pkgRef: string)

buildInstalled:

builder: proc buildInstalled(name: string; release = true; debug = false; verbose = false; preferRef = ""; nimFlags: seq[string] = @[]; backend = "c"): bool

bumpCommand:

bump: proc bumpCommand(v: Values)

cachedVersions:

versions: proc cachedVersions(name: string): seq[DiscoveredVersion]

checkCommand:

build: proc checkCommand(v: Values)

checkNimConstraint:

configs: proc checkNimConstraint(nimble: clueNimbleParser.NimbleFile)

checkoutHead:

versions: proc checkoutHead(dest: string; refresh = false): bool

checkoutHeadRaw:

versions: proc checkoutHeadRaw(dest: string; refresh = false): bool

checkoutRef:

versions: proc checkoutRef(dest, refStr: string; refresh = false): bool

checkoutRefRaw:

versions: proc checkoutRefRaw(dest, refStr: string; refresh = false): bool

checkoutTag:

versions: proc checkoutTag(dest, tag: string): bool

checkoutTagRaw:

versions: proc checkoutTagRaw(dest, tag: string): bool

clonePackage:

versions: proc clonePackage(url, dest: string; refresh = false; nonInteractive = false): bool

closureOnDisk:

versions: proc closureOnDisk(name: string): bool

clueBasePath:

configs: let clueBasePath

clueBinPath:

configs: template clueBinPath(): string

clueBuildTempPath:

configs: template clueBuildTempPath(): string

configs: template clueCfg(): DatpkgrConfig

clueCloneStart:

configs: proc clueCloneStart(name, url: string)

configs: template clueDB(): Store

clueDBPath:

configs: template clueDBPath(): string

clueDevelopPath:

configs: template clueDevelopPath(): string

clueDocsDB:

configs: var clueDocsDB

clueDocsDBPath:

configs: let clueDocsDBPath

clueDocsPath:

configs: let clueDocsPath

clueFetchStart:

configs: proc clueFetchStart(name: string)

clueInstallStart:

configs: proc clueInstallStart(label: string)

configs: proc clueLog(level: LogLevel; msg: string)

configs: template cluePath(): string

cluePkgsCachePath:

configs: template cluePkgsCachePath(): string

cluePkgsPath:

configs: template cluePkgsPath(): string

clueRegistriesDir:

configs: template clueRegistriesDir(): string

clueSourcesPath:

configs: template clueSourcesPath(): string

clueSubmodules:

configs: proc clueSubmodules(name, dest: string)

collectInstalledDepNames:

versions: proc collectInstalledDepNames(rootNames: seq[string]): seq[string]

collectPathsWithLock:

build: proc collectPathsWithLock(projectDir: string; nimble: NimbleFile; activeRootFeatures: seq[string]; pkgName: string; verbose: bool): tuple[pathFlags: seq[string], featureDefines: string]

collectResolvedPaths:

build: proc collectResolvedPaths(nimble: NimbleFile; activeRootFeatures: seq[string]; pkgName: string; verbose: bool): tuple[ pathFlags: seq[string], featureDefines: string]

collectResolvedPathsDetailed:

build: proc collectResolvedPathsDetailed(nimble: NimbleFile; activeRootFeatures: seq[string]; pkgName: string; verbose: bool): tuple[pathFlags: seq[string], featureDefines: string, entries: seq[LockEntry]]

compressOn:

configs: proc compressOn(p: WebProfile): bool

computeNimbleHash:

lockfile: proc computeNimbleHash(nimble: NimbleFile; activeRootFeatures: seq[string]; nimVersion: string): string

createPullRequest:

publish: proc createPullRequest(token, user, branch, title, body: string): string

dbcheckCommand:

dbcheck: proc dbcheckCommand(v: Values)

dbcheckVersionsCommand:

dbcheck: proc dbcheckVersionsCommand(v: Values)

debugEnabled:

configs: template debugEnabled(): untyped

configs: proc debugLog(msg: string)

defaultColorsFlag:

configs: proc defaultColorsFlag(userFlags = ""): string

defaultSourceName:

configs: template defaultSourceName(): string

defaultToolchainFlags:

configs: proc defaultToolchainFlags(userFlags = ""): string

DeployConfig:

configs: object DeployConfig

dir: proc deployDir(cfg: DeployConfig; profileName, keyOverride: string; dryRun = false; yes = false; verbose = false): int

deployDirCommand:

deploy: proc deployDirCommand(v: Values)

deployInitCommand:

deploy: proc deployInitCommand(v: Values)

deployRemoteRelease:

releases: proc deployRemoteRelease(prof: DirProfile; auth: RemoteAuth; dryRun, yes, verbose: bool): int

web: proc deployWeb(cfg: DeployConfig; profileName, keyOverride: string; dryRun = false; yes = false; verbose = false; statusOnly = false): int

deployWebCommand:

deploy: proc deployWebCommand(v: Values)

detectNimVersion:

configs: proc detectNimVersion(): string

detectRepoUrl:

publish: proc detectRepoUrl(): string

developCommand:

manager: proc developCommand(v: Values)

devShadowWarningsEnabled:

versions: template devShadowWarningsEnabled(): var bool

configs: object DirConfig

DirProfile:

configs: object DirProfile

discoverVersions:

versions: proc discoverVersions(name, url: string; refresh = false; cloneOnMiss = true): seq[ DiscoveredVersion]

discoverVersionsBatch:

versions: proc discoverVersionsBatch(pkgs: openArray[PkgRef]; refresh = false; onDone: proc ( name: string; versions: int; cached: bool) = nil): Table[string, seq[DiscoveredVersion]]

docsGenCommand:

docs: proc docsGenCommand(v: Values)

docsOpenCommand:

docs: proc docsOpenCommand(v: Values)

doctorCommand:

doctor: proc doctorCommand(v: Values)

downloadFile:

releases: proc downloadFile(url, dest: string): bool

dumpCommand:

manager: proc dumpCommand(v: Values)

ensureFork:

publish: proc ensureFork(user, token: string): bool

ensureFreshRegistry:

sources: proc ensureFreshRegistry(sourceFilter = ""; ttlHours = registryTtlHours)

ensureNimscriptEnv:

nimscript: proc ensureNimscriptEnv(nimblePath: string)

ensureRemoteAuth:

remotes: proc ensureRemoteAuth(user, host, key: string): tuple[auth: RemoteAuth, ok: bool]

ensureSourcesFile:

configs: proc ensureSourcesFile()

entryExists:

publish: proc entryExists(packagesJson: JsonNode; name: string): bool

live: proc error(live: Live; msg: string)

live: proc event(live: Live; text: string)

execNimscript:

nimscript: proc execNimscript(nimblePath, actionName: string; args: seq[string] = @[]; passNim: seq[string] = @[]): int

execNimscriptCode:

nimscript: proc execNimscriptCode(code: string; actionName: string): int

execNimscriptWithOutput:

nimscript: proc execNimscriptWithOutput(nimblePath, actionName: string; args: seq[string] = @[]; passNim: seq[string] = @[]): tuple[ exitCode: int, output: string]

expandForgeAlias:

publish: proc expandForgeAlias(s: string): string

expandPath:

configs: proc expandPath(s: string): string

extractArchive:

releases: proc extractArchive(workDir, archive: string): bool

fetchAllPkgMetas:

configs: proc fetchAllPkgMetas(pkgName: string): seq[PkgRef]

fetchCommand:

manager: proc fetchCommand(v: Values)

fetchPkgMeta:

configs: proc fetchPkgMeta(pkgName: string; sourceFilter: string = ""): Option[PkgRef]

findDeployConfig:

configs: proc findDeployConfig(customPath = ""): string

findNimbleFile:

nimbleparser: proc findNimbleFile(dir: string; cfg: DatpkgrConfig = nil; projectFs: Filesystem = nil): string

findReleaseBinary:

releases: proc findReleaseBinary(dir, binary: string): string

generateOverview:

overviewgen: proc generateOverview()

getClueCfg:

configs: proc getClueCfg(): DatpkgrConfig

versions: proc getDeps(name, version: string; features: seq[string] = @[]; refresh = false; url = ""): seq[PkgDependency]

getDocsTable:

configs: proc getDocsTable(): DbTable

gitHeadInfo:

versions: proc gitHeadInfo(name, url: string): Option[GitHeadInfo]

gitHubUser:

publish: proc gitHubUser(token: string): string

headVersion:

versions: proc headVersion(name: string): Version

configs: proc initClue()

initCommand:

init: proc initCommand(v: Values)

initDeploy:

init: proc initDeploy(deployType: string; yes, force: bool)

initDocsDB:

configs: proc initDocsDB()

installCleanCopy:

nimbleparser: proc installCleanCopy(cacheDir, verDir: string; nimble: NimbleFile)

installCommand:

manager: proc installCommand(v: Values)

installedCount:

versions: proc installedCount(): int

installedFeatures:

versions: proc installedFeatures(): Table[string, seq[string]]

installedPath:

versions: proc installedPath(name, version: string): string

installedRecords:

versions: proc installedRecords(name: string): seq[di.InstalledRecord]

installedRoots:

versions: proc installedRoots(): seq[string]

installedVersionForReuse:

versions: proc installedVersionForReuse(name, refStr: string): string

installPackage:

manager: proc installPackage(pkgName: string; pkgRef: string = ""; refresh = false; features: seq[string] = @[]; verbose = true; url = ""; doBuild = false; buildRelease = true; buildDebug = false; constraint: VersionConstraint = VersionConstraint(kind: vcAny, version: newVersion(0, 0, 0, "", "")); backend = "c"; sourceFilter: string = ""; suppressSummary = false; depsOnly = false; showTree = true)

invalidateLock:

lockfile: proc invalidateLock(pkgDir: string)

isArchiveAsset:

releases: proc isArchiveAsset(name: string): bool

isCruftName:

nimbleparser: proc isCruftName(name: string; nimble: NimbleFile): bool

isDevelopAvailable:

versions: proc isDevelopAvailable(name: string): bool

isDevInstall:

versions: proc isDevInstall(rec: di.InstalledRecord): bool

isForgeAliasShape:

publish: proc isForgeAliasShape(s: string): bool

manager: proc isGitUrl(s: string): bool

isInsidePkgs:

configs: proc isInsidePkgs(dir: string): bool

isInstalledOnDisk:

versions: proc isInstalledOnDisk(name: string): bool

isRegistryStale:

sources: proc isRegistryStale(cachePath: string; ttlHours = registryTtlHours): bool

isRemoteHost:

remotes: proc isRemoteHost(host: string): bool

isValidSourceName:

configs: proc isValidSourceName(s: string): bool

latestDownloadUrl:

releases: proc latestDownloadUrl(repo, asset: string): string

nimscript: proc listTasks(nimblePath: string): seq[tuple[name, description: string]]

live: type Live

loadSources:

configs: proc loadSources(): seq[Source]

lockfile: object LockEntry

lockfile: object LockFile

LockFileName:

lockfile: const LockFileName

lockPathFor:

lockfile: proc lockPathFor(pkgDir: string): string

lockToFlags:

lockfile: proc lockToFlags(lock: LockFile; pkgName: string; activeRootFeatures: seq[string]): tuple[ pathFlags: seq[string], featureDefines: string]

LockVersion:

lockfile: const LockVersion

markInstalledRoot:

versions: proc markInstalledRoot(name, version: string)

live: proc newLive(text: string; time = true): Live

newLockFile:

lockfile: proc newLockFile(root, nimbleHash, nimVersion: string; activeFeatures: seq[string]; packages: seq[LockEntry]): LockFile

newProjectDisk:

configs: proc newProjectDisk(dir = getCurrentDir()): Filesystem

NimbleDependency:

nimbleparser: object NimbleDependency

NimbleFile:

nimbleparser: object NimbleFile

nimbleLocalPackages:

configs: template nimbleLocalPackages(): string

nimbleManifestFileName:

nimbleparser: proc nimbleManifestFileName(pkgName: string): string

nimbleManifestParser:

nimbleparser: proc nimbleManifestParser(content: string; path: string): dt.Manifest

nimblePackagesUrl:

configs: template nimblePackagesUrl(): string

nimbleTokenPath:

publish: proc nimbleTokenPath(): string

normalizeRepoUrl:

publish: proc normalizeRepoUrl(url: string): string

normalizeTestFilter:

build: proc normalizeTestFilter(raw: string): string

packagesApiBase:

publish: const packagesApiBase

packagesApiRoot:

publish: const packagesApiRoot

packagesDefaultBranch:

publish: const packagesDefaultBranch

packagesUpstream:

publish: const packagesUpstream

packagesUpstreamUrl:

publish: const packagesUpstreamUrl

parseDeployConfig:

configs: proc parseDeployConfig(path: string): DeployConfig

parseFeatureFlags:

manager: proc parseFeatureFlags(s: string): seq[string]

parseNimbleFile:

nimbleparser: proc parseNimbleFile(path: string): NimbleFile

parseNimbleString:

nimbleparser: proc parseNimbleString(code: string): NimbleFile

parseRequiresArg:

nimbleparser: proc parseRequiresArg(arg: string): NimbleDependency

parseRequiresLine:

nimbleparser: proc parseRequiresLine(deps: var seq[NimbleDependency]; line: string)

configs: proc partialOn(p: WebProfile): bool

pkgNameFromUrl:

manager: proc pkgNameFromUrl(url: string): string

manager: proc pluralize(n: int; singular: string): string

pruneCommand:

manager: proc pruneCommand(v: Values)

pruneOrphans:

versions: proc pruneOrphans(verbose = true)

publishCommand:

publish: proc publishCommand(v: Values)

publishEntry:

publish: proc publishEntry(name, url, description, license, web: string; tags: seq[string]): JsonNode

publishTokenEnv:

publish: const publishTokenEnv

lockfile: proc readLock(pkgDir: string): tuple[ok: bool, lock: LockFile]

readPublishToken:

publish: proc readPublishToken(): string

rebuildDocs:

builder: proc rebuildDocs()

recordInstall:

versions: proc recordInstall(name, version: string; deps: seq[types.DepEntry]; root = false; features: seq[string] = @[]; installPath = "")

refreshAllSources:

configs: proc refreshAllSources(): bool

refreshRegistry:

configs: proc refreshRegistry(): bool

refreshSource:

configs: proc refreshSource(sourceName: string): bool

registryTtlHours:

sources: const registryTtlHours

ReleaseConfig:

configs: object ReleaseConfig

RemoteAuth:

remotes: object RemoteAuth

renameHook:

resetClueForTests:

configs: proc resetClueForTests()

resolveInstalledPath:

versions: proc resolveInstalledPath(name, preferRef: string): string

resolveNimBin:

configs: proc resolveNimBin(): string

resolveRepoUrl:

publish: proc resolveRepoUrl(input: string): string

remotes: proc rsyncCmd(localSrc, dest, user, host: string; port: int; auth: RemoteAuth; timeout: int; dryRun, delete, checksum, compress: bool; exclude: seq[string]): string

runNimscriptHook:

nimscript: proc runNimscriptHook(nimblePath, action: string; before: bool): bool

configs: object RunStep

runStepsLocal:

remotes: proc runStepsLocal(steps: seq[RunStep]; dryRun, verbose: bool): int

runStepsRemote:

remotes: proc runStepsRemote(user, host: string; port, timeout: int; auth: RemoteAuth; steps: seq[RunStep]; dryRun, verbose: bool): int

safeRemoveDir:

configs: proc safeRemoveDir(dir: string)

safeRemoveSymlink:

configs: proc safeRemoveSymlink(p: string)

saveSources:

configs: proc saveSources(sources: seq[Source])

sdDaemonReload:

configs: proc sdDaemonReload(s: SystemdConfig): bool

configs: proc sdRestart(s: SystemdConfig): bool

configs: proc sdStatus(s: SystemdConfig): bool

configs: proc sdSudo(s: SystemdConfig): bool

seedPackagesTable:

configs: proc seedPackagesTable(nimblePackages: JsonNode; source: string = defaultSourceName): int

selfImportPaths:

nimbleparser: proc selfImportPaths(pkgDir: string; nimble: NimbleFile): seq[string]

httpserver: proc serveDocs(docDir, pkgName: string; port: Port)

live: proc setMain(live: Live; text: string)

releases: proc shq(s: string): string

sourceAddCommand:

sources: proc sourceAddCommand(v: Values)

sourceCachePath:

configs: proc sourceCachePath(name: string): string

sourceFetchCommand:

sources: proc sourceFetchCommand(v: Values)

sourceListCommand:

sources: proc sourceListCommand(v: Values)

sourceRemoveCommand:

sources: proc sourceRemoveCommand(v: Values)

splitPkgRef:

builder: proc splitPkgRef(s: string): tuple[name, version: string]

splitPublishTags:

publish: proc splitPublishTags(s: string): seq[string]

remotes: proc sshCmd(user, host: string; port: int; auth: RemoteAuth; timeout: int; remote: string): string

sshTransport:

remotes: proc sshTransport(user, host: string; port: int; auth: RemoteAuth; timeout: int): string

sshTransportArgs:

remotes: proc sshTransportArgs(port: int; auth: RemoteAuth; timeout: int): string

stageReleaseAsset:

releases: proc stageReleaseAsset(repo, asset, binary, workDir: string; verbose: bool): tuple[ stageDir: string, ok: bool]

live: proc start(live: Live)

remotes: proc stepLabel(s: RunStep): string

build: proc storeLock(projectDir: string; nimble: NimbleFile; activeRootFeatures: seq[string]; pkgName: string; entries: seq[LockEntry])

live: proc success(live: Live; msg: string)

SystemdConfig:

configs: object SystemdConfig

tagForVersion:

versions: proc tagForVersion(dest: string; version: string): string

taskCommand:

nimscript: proc taskCommand(v: Values)

testCommand:

build: proc testCommand(v: Values)

toGitSshUrl:

versions: proc toGitSshUrl(url: string): string

toMsysPath:

remotes: proc toMsysPath(path: string): string

tryLockedFlags:

build: proc tryLockedFlags(projectDir: string; nimble: NimbleFile; activeRootFeatures: seq[string]; pkgName: string; verbose: bool): tuple[ hit: bool, pathFlags: seq[string], featureDefines: string]

uninstallCommand:

manager: proc uninstallCommand(v: Values)

unrecordInstall:

versions: proc unrecordInstall(name, version: string)

updateCommand:

manager: proc updateCommand(v: Values)

upgradeCommand:

upgrade: proc upgradeCommand(v: Values)

validateLock:

lockfile: proc validateLock(lock: LockFile; nimble: NimbleFile; activeRootFeatures: seq[string]; nimVersion: string; developDir: string): bool

validateSteps:

remotes: proc validateSteps(steps: seq[RunStep]; profileName: string): bool

venvCommand:

manager: proc venvCommand(v: Values)

versionsCommand:

manager: proc versionsCommand(v: Values)

versionsDB:

configs: template versionsDB(): Store

versionsDBPath:

configs: template versionsDBPath(): string

configs: object WebConfig

WebProfile:

configs: object WebProfile

withClueDB:

configs: template withClueDB(body: untyped)

withDocsDB:

configs: template withDocsDB(stmt)

withNimbleSupport:

nimbleparser: proc withNimbleSupport(cfg: dc.DatpkgrConfig; parser: dt.ManifestParser)

lockfile: proc writeLock(pkgDir: string; lock: LockFile)