☰

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/sources, clue/commands/upgrade, clue/deploy/configs, clue/deploy/init, clue/deploy/web, clue/docbuilder/builder, clue/docbuilder/configs, clue/docbuilder/httpserver, clue/docbuilder/overviewgen, clue/pkgmanager/builder, clue/pkgmanager/configs, clue/pkgmanager/nimbleparser, clue/pkgmanager/resolver, clue/pkgmanager/versions.

API symbols

allInstalledPaths:

versions: proc allInstalledPaths(): seq[string]

buildCommand:

build: proc buildCommand(v: Values)

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

clueBasePath:

configs: let clueBasePath

clueBinPath:

configs: template clueBinPath(): string

clueBuildTempPath:

configs: template clueBuildTempPath(): string

configs: template clueCfg(): DatpkgrConfig

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

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

collectInstalledDepNames:

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

collectResolvedPaths:

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

compressOn:

configs: proc compressOn(p: WebProfile): bool

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

deployInitCommand:

deploy: proc deployInitCommand(v: Values)

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

deployWebCommand:

deploy: proc deployWebCommand(v: Values)

detectNimVersion:

developCommand:

manager: proc developCommand(v: Values)

devShadowWarningsEnabled:

versions: template devShadowWarningsEnabled(): var bool

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)

dumpCommand:

manager: proc dumpCommand(v: Values)

ensureSourcesFile:

configs: proc ensureSourcesFile()

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]

expandPath:

configs: proc expandPath(s: string): string

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

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]

GithubConfig:

configs: object GithubConfig

gitOriginRepo:

init: proc gitOriginRepo(): string

headVersion:

versions: proc headVersion(name: string): Version

configs: proc initClue()

initCommand:

init: proc initCommand(v: Values)

initDeploy:

init: proc initDeploy(deployType: string; writeWorkflow, 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]

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)

isCruftName:

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

isDevInstall:

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

manager: proc isGitUrl(s: string): bool

isInsidePkgs:

configs: proc isInsidePkgs(dir: string): bool

isValidSourceName:

configs: proc isValidSourceName(s: string): bool

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

live: type Live

loadSources:

configs: proc loadSources(): seq[Source]

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

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

parseDeployConfig:

configs: proc parseDeployConfig(path: string): DeployConfig

parseFeatureFlags:

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

parseGitRepo:

init: proc parseGitRepo(url: string): 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)

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

ReleaseConfig:

configs: object ReleaseConfig

ReleaseTarget:

configs: object ReleaseTarget

resetClueForTests:

configs: proc resetClueForTests()

resolveInstalledPath:

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

resolveNimBin:

configs: proc resolveNimBin(): string

runNimscriptHook:

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

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

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

live: proc setMain(live: Live; text: 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]

live: proc start(live: Live)

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

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)

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)