Index

Modules: nimph, nimph/asjson, nimph/config, nimph/dependency, nimph/doctor, nimph/group, nimph/locker, nimph/nimble, nimph/package, nimph/project, nimph/requirement, nimph/runner, nimph/spec, nimph/thehub, nimph/version, nimph/versiontags, rest.

API symbols

`$`:

• dependency: `$`(dependency: Dependency): string
• package: `$`(package: Package): string
• project: `$`(project: Project): string
• requirement: `$`(req: Requirement): string
• version: `$`(spec: Release): string
• version: `$`(mask: VersionMask): string
• version: `$`(field: VersionMaskField): string
• rest: `$`(e: ref RestError): string
• rest: `$`(c: RestCall): string

`<=`:

• version: `<=`(a, b: Release): bool

`<`:

• version: `<`(a, b: Release): bool
• version: `<`(a, b: VersionMaskField): bool

`//////`:

• spec: `//////`(a: string | AbsoluteFile | AbsoluteDir): string

`///`:

• spec: `///`(a: AbsoluteFile | AbsoluteDir): string
• spec: `///`(a: string): string

`==`:

• project: `==`(a, b: Project): bool
• version: `==`(a, b: Release): bool
• version: `==`(a: VersionMask; b: Version): bool
• version: `==`(a, b: VersionMask): bool
• version: `==`(a, b: VersionMaskField): bool

`[]=`:

• group: `[]=`[K, V](group: Group[K, V]; key: K; value: V)
• version: `[]=`(mask: var VersionMask; index: VersionIndex; value: VersionMaskField)
• versiontags: `[]=`(group: var VersionTags; ver: Version; thing: GitThing)

`[]`:

• group: `[]`[K, V](group: var Group[K, V]; key: K): var V
• group: `[]`[K, V](group: Group[K, V]; key: K): V
• versiontags: `[]`(group: VersionTags; ver: Version): var GitThing
• versiontags: `[]`(group: VersionTags; ver: VersionMask): var GitThing

acceptable:

• version: acceptable(mask: VersionMaskField; op: Operator; value: VersionField): bool

add:

• dependency: add(group: var DependencyGroup; req: Requirement; dep: Dependency)
• group: add[K: string; V](group: Group[K, V]; key: K; value: V)
• group: add[K: string; V](group: Group[K, V]; url: Uri; value: V)
• group: add[K: Uri; V](group: Group[K, V]; url: Uri; value: V)
• locker: add(room: var LockerRoom; req: Requirement; name: string; project: Project)
• thehub: add(group: var HubGroup; hub: HubResult)
• versiontags: add(group: var VersionTags; ver: Version; thing: GitThing)

addedRequirements:

• dependency: addedRequirements(dependencies: var DependencyGroup; dependency: var Dependency): bool

addLockerRoom:

• config: addLockerRoom(config: var NimphConfig; name: string; room: JsonNode)

addMissingSearchPathsTo:

• project: addMissingSearchPathsTo(project: var Project; cloned: var Project)

addMissingUpstreams:

• project: addMissingUpstreams(project: Project)

addName:

• versiontags: addName(group: var VersionTags; version: Version; thing: GitThing)
• versiontags: addName(group: var VersionTags; mask: VersionMask; thing: GitThing)

addSearchPath:

• config: addSearchPath(config: ConfigRef; nimcfg: Target; path: string): bool
• project: addSearchPath(project: Project; path: string): bool
• project: addSearchPath(project: var Project; path: string): bool

adopt:

• dependency: adopt(parent: Project; child: var Project)
• requirement: adopt(parent: var Requirement; child: Requirement)

ageInDays:

• package: ageInDays(found: PackagesResult): int64

aimAt:

• package: aimAt(package: Package; req: Requirement): Package

allImportTargets:

• project: allImportTargets(config: ConfigRef; repo: string): OrderedTableRef[Target, LinkedSearchResult]

allLockerRooms:

• locker: allLockerRooms(project: Project): LockerRoom

appendConfig:

• config: appendConfig(path: Target; config: string): bool

asFoundVia:

• project: asFoundVia(group: var ProjectGroup; config: ConfigRef; repo: string): var Project

asPackage:

• dependency: asPackage(project: Project): Package

asUrlAnchor:

• requirement: asUrlAnchor(release: Release): string

at:

• version: at[T: Version | VersionMask](version: T; index: VersionIndex): auto

AtLeast:

• Operator.AtLeast

authorize:

• thehub: authorize(request: Recallable): bool

availableProjects:

• project: availableProjects(project: Project): ProjectGroup

bare:

• spec: bare(url: Uri): Uri

bareUrlsAreEqual:

• spec: bareUrlsAreEqual(a, b: Uri): bool

bestRelease:

• project: bestRelease(tags: GitTagTable; goal: RollGoal): Version

betterReleaseExists:

• project: betterReleaseExists(project: var Project; goal: RollGoal): bool

CallRequestError:

• rest: CallRequestError

Caret:

• Operator.Caret

childProjects:

• dependency: childProjects(project: Project): ProjectGroup

children:

• requirement: children(parent: Requirement; andParent = false): Requirement

clear:

• group: clear[K, V](group: Group[K, V])

clone:

• project: clone(project: var Project; url: Uri; name: string; cloned: var Project): bool

cloner:

• nimph: cloner(args: seq[string]; strict = false; log_level = logLevel; safe_mode = false; quiet = true; network = true; force = false; dry_run = false): int

configFile:

• spec: configFile

contains:

• dependency: contains(dependencies: DependencyGroup; package: Package): bool
• group: contains[K, V](group: Group[K, V]; key: K): bool
• group: contains[K, V](group: Group[K, V]; url: Uri): bool
• group: contains[K, V](group: Group[K, V]; value: V): bool

convertToGit:

• spec: convertToGit(uri: Uri): Uri

convertToSsh:

• spec: convertToSsh(uri: Uri): Uri

countNimblePaths:

• project: countNimblePaths(project: Project): tuple[local: int, global: int, paths: seq[string]]

createUrl:

• project: createUrl(project: Project; refresh = false): Uri
• project: createUrl(project: var Project; refresh = false): Uri

cuteRelease:

• project: cuteRelease(project: Project): string

defaultFlags:

• spec: defaultFlags

defaultRemote:

• spec: defaultRemote

del:

• group: del[K: string; V](group: Group[K, V]; name: K)
• group: del[K: Uri; V](group: Group[K, V]; url: K)
• versiontags: del(group: var VersionTags; ver: Version)

delName:

• group: delName(group: Group; key: string)

demandHead:

• project: demandHead(repository: GitRepository): string
• project: demandHead(project: Project): string

DepDir:

• spec: DepDir

Dependency:

• dependency: Dependency

DependencyGroup:

• dependency: DependencyGroup

describe:

• requirement: describe(requirement: Requirement): string

destylize:

• spec: destylize(s: string): string

determineDeps:

• dependency: determineDeps(project: Project): Option[Requires]
• dependency: determineDeps(project: var Project): Option[Requires]

DistMethod:

• package: DistMethod

doctor:

• doctor: doctor(project: var Project; dry = true; strict = true): bool

dotGit:

• spec: dotGit

dotHg:

• spec: dotHg

dotNimble:

• spec: dotNimble

dotNimbleLink:

• spec: dotNimbleLink

Downgrade:

• RollGoal.Downgrade

DrError:

• StateKind.DrError

DrOkay:

• StateKind.DrOkay

DrRetry:

• StateKind.DrRetry

DrState:

• doctor: DrState

DumpResult:

• nimble: DumpResult

effectively:

• version: effectively(release: Release): Version
• version: effectively(mask: VersionMask): Version

emptyRelease:

• spec: emptyRelease

Equal:

• Operator.Equal

excludeMissingLazyPaths:

• spec: excludeMissingLazyPaths

excludeMissingSearchPaths:

• spec: excludeMissingSearchPaths

excludeSearchPath:

• config: excludeSearchPath(config: ConfigRef; nimcfg: Target; path: string): bool
• project: excludeSearchPath(project: Project; path: string): bool
• project: excludeSearchPath(project: var Project; path: string): bool

extantSearchPaths:

• config: extantSearchPaths(config: ConfigRef; least = 0): string

fetchConfig:

• project: fetchConfig(project: var Project; force = false): bool

fetchDump:

• project: fetchDump(project: var Project; refresh = false): bool
• project: fetchDump(project: var Project; package: string; refresh = false): bool

fetchNimbleDump:

• nimble: fetchNimbleDump(path: string; nimbleDir = ""): DumpResult

fetchNimbleMeta:

• nimble: fetchNimbleMeta(path: string): NimbleMeta

fetchTagTable:

• project: fetchTagTable(project: var Project)

findCurrentTag:

• project: findCurrentTag(project: Project): Release
• project: findCurrentTag(project: var Project): Release

findGithubToken:

• thehub: findGithubToken(): Option[string]

findProject:

• project: findProject(project: var Project; dir: string; parent: Project = nil): bool

findRepositoryUrl:

• project: findRepositoryUrl(project: Project; name = defaultRemote): Option[Uri]

fixDependencies:

• doctor: fixDependencies(project: var Project; group: var DependencyGroup; state: var DrState): bool

fixer:

• nimph: fixer(strict = false; log_level = logLevel; safe_mode = false; quiet = false; network = true; force = false; dry_run = false): int

fixTags:

• doctor: fixTags(project: var Project; dry_run = true; force = false): bool

Flag:

• spec: Flag

forker:

• nimph: forker(names: seq[string]; strict = false; log_level = logLevel; safe_mode = false; quiet = false; network = true; force = false; dry_run = false): int

forkHub:

• thehub: forkHub(owner: string; repo: string): Option[HubResult]

forkTarget:

• project: forkTarget(project: Project): ForkTargetResult
• spec: forkTarget(url: Uri): ForkTargetResult

ForkTargetResult:

• spec: ForkTargetResult

get:

• dependency: get[K: Requirement; V](group: Group[K, V]; key: Requirement): V
• group: get[K: string; V](group: Group[K, V]; key: K): V

getAllLockerRooms:

• config: getAllLockerRooms(config: NimphConfig): JsonNode

getGitHubUser:

• thehub: getGitHubUser(): Option[HubResult]

getHeadOid:

• project: getHeadOid(project: Project): GitResult[GitOid]

getLockerRoom:

• config: getLockerRoom(config: NimphConfig; name: string): JsonNode
• locker: getLockerRoom(project: Project; name: string; room: var LockerRoom): bool

getOfficialPackages:

• package: getOfficialPackages(nimbleDir: string): PackagesResult

getProjectIn:

• project: getProjectIn(group: ProjectGroup; directory: string): Project

ghTokenEnv:

• spec: ghTokenEnv

ghTokenFn:

• spec: ghTokenFn

Git:

• DistMethod.Git

gitDir:

• project: gitDir(project: Project): string

grapher:

• nimph: grapher(names: seq[string]; strict = false; log_level = logLevel; safe_mode = false; quiet = true; network = true; force = false; dry_run = false): int

Group:

• group: Group

guessVersion:

• project: guessVersion(project: Project): Version

hasGit:

• project: hasGit(project: Project): bool

hash:

• locker: hash(locker: Locker): Hash
• locker: hash(room: LockerRoom): Hash
• requirement: hash(req: Requirement): Hash
• spec: hash(url: Uri): Hash
• version: hash(release: Release): Hash
• version: hash(mask: VersionMask): Hash
• version: hash(field: VersionMaskField): Hash

hasHg:

• project: hasHg(project: Project): bool

hasKey:

• dependency: hasKey(dependencies: DependencyGroup; name: string): bool
• group: hasKey[K, V](group: Group[K, V]; key: K): bool

hasLocalDeps:

• project: hasLocalDeps(project: Project): bool

hasNimph:

• project: hasNimph(project: Project): bool

hasProjectIn:

• project: hasProjectIn(group: ProjectGroup; directory: string): bool

hasReleaseTag:

• project: hasReleaseTag(project: Project): bool

hasUrl:

• nimble: hasUrl(meta: NimbleMeta): bool
• package: hasUrl(group: PackageGroup; url: Uri): bool

hgDir:

• project: hgDir(project: Project): string

HubCode:

• HubKind.HubCode

HubCommit:

• HubKind.HubCommit

HubCommitMeta:

• thehub: HubCommitMeta

HubContact:

• thehub: HubContact

HubGroup:

• thehub: HubGroup

HubIssue:

• HubKind.HubIssue

HubKind:

• thehub: HubKind

HubPull:

• HubKind.HubPull

HubRelease:

• HubKind.HubRelease

HubRepo:

• HubKind.HubRepo

HubResult:

• thehub: HubResult

HubSort:

• thehub: HubSort

HubSortBy:

• thehub: HubSortBy

HubTag:

• HubKind.HubTag

hubTime:

• thehub: hubTime

hubTokenFn:

• spec: hubTokenFn

HubTree:

• thehub: HubTree

HubUser:

• HubKind.HubUser

HubVerification:

• thehub: HubVerification

importName:

• package: importName(package: Package): string
• project: importName(linked: LinkedSearchResult): string
• project: importName(project: Project): string
• requirement: importName(requirement: Requirement): string
• spec: importName(path: string): string
• spec: importName(url: Uri): string
• version: importName(target: Target): string

init:

• group: init[K, V](group: Group[K, V]; flags: set[Flag]; mode = modeStyleInsensitive)
• thehub: init(result: var HubResult; js: JsonNode)

initRestClient:

• rest: initRestClient(self: RestClient)

inventRelease:

• project: inventRelease(project: var Project)

isEmpty:

• config: isEmpty(config: NimphConfig): bool

isHappy:

• dependency: isHappy(dependency: Dependency): bool

isHappyWithVersion:

• dependency: isHappyWithVersion(dependency: Dependency): bool

isLink:

• nimble: isLink(meta: NimbleMeta): bool

isSatisfiedBy:

• dependency: isSatisfiedBy(req: Requirement; project: Project): bool
• dependency: isSatisfiedBy(req: Requirement; project: Project; release: Release): bool
• requirement: isSatisfiedBy(req: Requirement; spec: Release): bool

isSpecific:

• version: isSpecific(release: Release): bool

isStdlib:

• config: isStdlib(config: ConfigRef; path: AbsoluteDir): bool

isStdLib:

• config: isStdLib(config: ConfigRef; path: string): bool

issueRequest:

• rest: issueRequest(rec: Recallable): Response

isUrl:

• requirement: isUrl(requirement: Requirement): bool

isUsing:

• dependency: isUsing(dependencies: DependencyGroup; target: Target; outside: Dependency = nil): bool

isValid:

• nimble: isValid(meta: NimbleMeta): bool
• requirement: isValid(req: Requirement): bool
• spec: isValid(url: Uri): bool
• version: isValid(release: Release): bool

isVirtual:

• requirement: isVirtual(requirement: Requirement): bool

items:

• version: items[T: Version | VersionMask](version: T): auto

keys:

• group: keys[K, V](group: Group[K, V]): K

knowVersion:

• project: knowVersion(project: var Project): Version

len:

• group: len(group: Group): int
• group: len[K, V](group: Group[K, V]): int

likelyLazy:

• config: likelyLazy(config: ConfigRef; least = 0): string
• config: likelyLazy(config: ConfigRef; repo: string; least = 0): string

likelySearch:

• config: likelySearch(config: ConfigRef; libsToo: bool): string
• config: likelySearch(config: ConfigRef; repo: string; libsToo: bool): string

likelyTags:

• version: likelyTags(version: Version): string

LinkedSearchResult:

• project: LinkedSearchResult

loadAllCfgs:

• config: loadAllCfgs(directory: string): ConfigRef

Local:

• DistMethod.Local

localDeps:

• project: localDeps(project: Project): string

lock:

• locker: lock(project: var Project; name: string; flags = defaultFlags): bool

Locker:

• locker: Locker

LockerRoom:

• locker: LockerRoom

lockfiler:

• nimph: lockfiler(names: seq[string]; strict = false; log_level = logLevel; safe_mode = false; quiet = false; network = true; force = false; dry_run = false): int

massageHeaders:

• rest: massageHeaders(node: JsonNode): seq[KeyVal]

matches:

• versiontags: matches(tags: GitTagTable; against: HashSet[Hash]; head: string = ""): tuple[ release: Release, thing: GitThing]

matching:

• package: matching(group: PackageGroup; req: Requirement): PackageGroup

matchingBranches:

• project: matchingBranches(project: Project; oid: GitOid): GitReference
• project: matchingBranches(project: Project; name: string): GitReference

Merc:

• DistMethod.Merc

mget:

• dependency: mget[K: Requirement; V](group: var Group[K, V]; key: K): var V
• group: mget[K: string; V](group: var Group[K, V]; key: K): var V

mgetProjectIn:

• project: mgetProjectIn(group: var ProjectGroup; directory: string): var Project

missingSearchPaths:

• project: missingSearchPaths(project: Project; target: Project): string
• project: missingSearchPaths(project: Project; target: var Project): string

mpairs:

• group: mpairs[K, V](group: Group[K, V]): tuple[key: K, val: var V]

mvalues:

• group: mvalues[K, V](group: var Group[K, V]): var V

name:

• dependency: name(dependency: Dependency): string

Nest:

• DistMethod.Nest

newDependency:

• dependency: newDependency(project: Project): Dependency
• dependency: newDependency(requirement: Requirement): Dependency

newDependencyGroup:

• dependency: newDependencyGroup(project: Project; flags = defaultFlags): DependencyGroup
• dependency: newDependencyGroup(flags: set[Flag]): DependencyGroup

newHubCommitMeta:

• thehub: newHubCommitMeta(js: JsonNode): HubCommitMeta

newHubContact:

• thehub: newHubContact(js: JsonNode): HubContact

newHubGroup:

• thehub: newHubGroup(flags: set[Flag] = defaultFlags): HubGroup

newHubResult:

• thehub: newHubResult(kind: HubKind; js: JsonNode): HubResult

newHubTree:

• thehub: newHubTree(js: JsonNode): HubTree

newLockerRoom:

• locker: newLockerRoom(project: Project; flags = defaultFlags): LockerRoom
• locker: newLockerRoom(name = ""; flags = defaultFlags): LockerRoom

newNimphConfig:

• config: newNimphConfig(path: string): NimphConfig

newPackage:

• package: newPackage(name: string; dist: DistMethod; url: Uri): Package
• package: newPackage(name: string; path: string; dist: DistMethod; url: Uri): Package
• package: newPackage(url: Uri): Package

newPackageGroup:

• package: newPackageGroup(flags: set[Flag] = defaultFlags): PackageGroup

newProject:

• project: newProject(nimble: Target): Project

newProjectGroup:

• project: newProjectGroup(flags: set[Flag] = defaultFlags): ProjectGroup

newRecallable:

• rest: newRecallable(call: RestCall; url: Uri; headers: HttpHeaders; body: string): Recallable

newRelease:

• version: newRelease(reference: string; operator = Equal): Release
• version: newRelease(version: Version): Release

newRequirement:

• requirement: newRequirement(id: string; operator: Operator; release: Release; notes = ""): Requirement
• requirement: newRequirement(id: string; operator: Operator; spec: string): Requirement

newRestClient:

• rest: newRestClient(): RestClient

newVersionTags:

• versiontags: newVersionTags(flags = defaultFlags): VersionTags

nextTagFor:

• project: nextTagFor(tags: GitTagTable; version: Version): string

nimbleDir:

• project: nimbleDir(project: Project): string

NimbleMeta:

• nimble: NimbleMeta

nimbleMeta:

• spec: nimbleMeta

nimbler:

• nimph: nimbler(args: seq[string]; strict = false; log_level = logLevel; safe_mode = false; quiet = true; network = true; force = false; dry_run = false): int

nimCfg:

• project: nimCfg(project: Project): Target

NimCfg:

• spec: NimCfg

NimphConfig:

• config: NimphConfig

nimphConfig:

• project: nimphConfig(project: Project): string

normalizeUrl:

• spec: normalizeUrl(uri: Uri): Uri

NotMore:

• Operator.NotMore

numberOfNimblePaths:

• project: numberOfNimblePaths(project: Project): int

officialPackages:

• spec: officialPackages

omitStars:

• version: omitStars(mask: VersionMask): string

Operator:

• version: Operator

orphans:

• requirement: orphans(parent: Requirement): Requirement

Over:

• Operator.Over

Package:

• package: Package

packageDirectory:

• project: packageDirectory(project: Project): string

PackageGroup:

• package: PackageGroup

packageName:

• spec: packageName(name: string): string
• spec: packageName(url: Uri): string

packagePaths:

• config: packagePaths(config: ConfigRef; exists = true): string

PackagesResult:

• package: PackagesResult

pairs:

• group: pairs[K, V](group: Group[K, V]): tuple[key: K, val: V]
• version: pairs[T: Version | VersionMask](version: T): auto

parseConfigFile:

• config: parseConfigFile(path: string): Option[ConfigRef]

parseDottedVersion:

• version: parseDottedVersion(input: string): Version

parseNimbleDump:

• nimble: parseNimbleDump(input: string): Option[StringTableRef]

parseProjectCfg:

• config: parseProjectCfg(input: Target): ProjectCfgParsed

parseRequires:

• requirement: parseRequires(input: string): Option[Requires]

parseVersionLoosely:

• version: parseVersionLoosely(content: string): Option[Release]

pather:

• nimph: pather(names: seq[string]; strict = false; log_level = logLevel; safe_mode = false; quiet = true; network = true; force = false; dry_run = false): int

pathForName:

• dependency: pathForName(dependencies: DependencyGroup; name: string): Option[string]
• project: pathForName(group: ProjectGroup; name: string): Option[string]

pathToImport:

• spec: pathToImport(path: string): string

peelRelease:

• dependency: peelRelease(project: Project): Release
• dependency: peelRelease(project: Project; release: Release): Release

PkgDir:

• spec: PkgDir

prepareForClone:

• spec: prepareForClone(uri: Uri): Uri

Project:

• project: Project

ProjectCfgParsed:

• config: ProjectCfgParsed

projectForName:

• dependency: projectForName(group: DependencyGroup; name: string): Option[Project]

projectForPath:

• dependency: projectForPath(deps: DependencyGroup; path: string): Option[Project]

ProjectGroup:

• project: ProjectGroup

promote:

• project: promote(project: Project; name = defaultRemote; user: HubResult = nil): bool

promoteRemoteLike:

• project: promoteRemoteLike(project: Project; url: Uri; name = defaultRemote): bool

Recallable:

• rest: Recallable

refresh:

• project: refresh(project: var Project)

Release:

• version: Release

releaseHashes:

• versiontags: releaseHashes(release: Release; thing: GitThing; head = ""): HashSet[Hash]
• versiontags: releaseHashes(release: Release; head = ""): HashSet[Hash]

Releases:

• project: Releases

releaseSummary:

• project: releaseSummary(project: Project): string

relocateDependency:

• project: relocateDependency(parent: var Project; project: var Project)

removeSearchPath:

• config: removeSearchPath(config: ConfigRef; nimcfg: Target; path: string): bool
• project: removeSearchPath(project: Project; path: string): bool
• project: removeSearchPath(project: var Project; path: string): bool

renderShortly:

• thehub: renderShortly(r: HubResult): string

repo:

• project: repo(project: Project): string

repoLockReady:

• project: repoLockReady(project: Project): bool

reqForProject:

• dependency: reqForProject(group: DependencyGroup; project: Project): Option[Requirement]

Requirement:

• requirement: Requirement

requirementChangingCommits:

• project: requirementChangingCommits(project: Project): RequirementsTags

Requirements:

• project: Requirements

RequirementsTags:

• project: RequirementsTags

Requires:

• requirement: Requires

reset:

• dependency: reset(dependencies: var DependencyGroup; project: var Project)

resolve:

• dependency: resolve(project: var Project; dependencies: var DependencyGroup): bool
• dependency: resolve(project: Project; deps: var DependencyGroup; req: Requirement): bool

resolveUsing:

• dependency: resolveUsing(projects: ProjectGroup; packages: PackageGroup; requirement: Requirement): Dependency

RestCall:

• rest: RestCall

RestClient:

• rest: RestClient

RestError:

• rest: RestError

RetriesExhausted:

• rest: RetriesExhausted

returnToHeadAfter:

• project: returnToHeadAfter(project: var Project; body: untyped)

reversed:

• group: reversed[K, V](group: Group[K, V]): V

richen:

• versiontags: richen(tags: GitTagTable): tuple[release: Release, thing: GitThing]

roll:

• dependency: roll(project: var Project; requirement: Requirement; goal: RollGoal; dry_run = false): bool

roller:

• nimph: roller(names: seq[string]; strict = false; log_level = logLevel; safe_mode = false; quiet = false; network = true; force = false; dry_run = false): int

RollGoal:

• spec: RollGoal

rollTowards:

• dependency: rollTowards(project: var Project; requirement: Requirement): bool

runner:

• nimph: runner(args: seq[string]; git = false; strict = false; log_level = logLevel; safe_mode = false; quiet = true; network = true; force = false; dry_run = false): int

RunOutput:

• runner: RunOutput

runSomething:

• project: runSomething(project: Project; exe: string; args: seq[string]; opts = {poParentStreams}): RunOutput
• project: runSomething(project: var Project; exe: string; args: seq[string]; opts = {poParentStreams}): RunOutput
• runner: runSomething(exe: string; args: seq[string]; options: set[ProcessOption]; nimbleDir = ""): RunOutput

searcher:

• nimph: searcher(args: seq[string]; strict = false; log_level = logLevel; safe_mode = false; quiet = true; network = true; force = false; dry_run = false): int

searchHub:

• thehub: searchHub(keywords: seq[string]; sort = Best; order = Descending): Option[ HubGroup]

semanticVersionStrings:

• version: semanticVersionStrings(version: Version): string
• version: semanticVersionStrings(mask: VersionMask): string

setHeadToRelease:

• project: setHeadToRelease(project: var Project; release: Release; paths: seq[string] = @[]): bool

shortDate:

• spec: shortDate

sortByVersion:

• project: sortByVersion(tags: GitTagTable): GitTagTable

Specific:

• RollGoal.Specific

specifically:

• version: specifically(release: Release): Version

stalePackages:

• spec: stalePackages

StateKind:

• doctor: StateKind

stripPkgs:

• runner: stripPkgs(nimbleDir: string): string

suggestNimbleDir:

• config: suggestNimbleDir(config: ConfigRef; local = ""; global = ""): string

symbolicMatch:

• dependency: symbolicMatch(project: Project; req: Requirement): bool
• dependency: symbolicMatch(project: Project; req: Requirement; release: Release): bool
• dependency: symbolicMatch(project: var Project; req: Requirement; release: Release): bool
• dependency: symbolicMatch(project: var Project; req: Requirement): bool

symbolicMatches:

• dependency: symbolicMatches(project: Project; req: Requirement): Release

Tag:

• Operator.Tag

tagger:

• nimph: tagger(strict = false; log_level = logLevel; safe_mode = false; quiet = false; network = true; force = false; dry_run = false): int

Tilde:

• Operator.Tilde

toDistMethod:

• asjson: toDistMethod(js: JsonNode): DistMethod

toJson:

• asjson: toJson(dist: DistMethod): JsonNode
• asjson: toJson(operator: Operator): JsonNode
• asjson: toJson(release: Release): JsonNode
• asjson: toJson(requirement: Requirement): JsonNode
• asjson: toJson(uri: Uri): JsonNode
• asjson: toJson(version: Version): JsonNode
• asjson: toJson(mask: VersionMask): JsonNode
• locker: toJson(locker: Locker): JsonNode
• locker: toJson(room: LockerRoom): JsonNode

toLocker:

• locker: toLocker(js: JsonNode): Locker

toLockerRoom:

• locker: toLockerRoom(js: JsonNode; name = ""): LockerRoom

toMask:

• version: toMask(version: Version): VersionMask

toOperator:

• asjson: toOperator(js: JsonNode): Operator

toRelease:

• asjson: toRelease(js: JsonNode): Release

toRequirement:

• asjson: toRequirement(js: JsonNode): Requirement

toUri:

• asjson: toUri(js: JsonNode): Uri

toUrl:

• package: toUrl(requirement: Requirement; group: PackageGroup): Option[Uri]
• requirement: toUrl(requirement: Requirement): Option[Uri]

toVersion:

• asjson: toVersion(js: JsonNode): Version

toVersionMask:

• asjson: toVersionMask(js: JsonNode): VersionMask

Under:

• Operator.Under

unlock:

• locker: unlock(project: var Project; name: string; flags = defaultFlags): bool

unlockfiler:

• nimph: unlockfiler(names: seq[string]; strict = false; log_level = logLevel; safe_mode = false; quiet = false; network = true; force = false; dry_run = false): int

updowner:

• nimph: updowner(names: seq[string]; goal: RollGoal; strict = false; log_level = logLevel; safe_mode = false; quiet = true; network = true; force = false; dry_run = false): int

Upgrade:

• RollGoal.Upgrade

upstreamRemote:

• spec: upstreamRemote

url:

• nimble: url(meta: NimbleMeta): Uri

urls:

• package: urls(group: PackageGroup): Uri

values:

• group: values[K, V](group: Group[K, V]): V

versionChangingCommits:

• project: versionChangingCommits(project: var Project): VersionTags

VersionField:

• version: VersionField

VersionIndex:

• version: VersionIndex

VersionMask:

• version: VersionMask

VersionMaskField:

• version: VersionMaskField

VersionTags:

• versiontags: VersionTags

WhatHappensInVegas:

• spec: WhatHappensInVegas

Wild:

• Operator.Wild

Wildlings:

• version: Wildlings

withinDirectory:

• spec: withinDirectory(path: string; body: untyped): untyped

writeNimbleDirPaths:

• spec: writeNimbleDirPaths

writeNimbleMeta:

• nimble: writeNimbleMeta(path: string; url: Uri; revision: string): bool