ezx
Search uses release 1.13.0.0 · 2,947 definitions
Definitions (2,947)
- def source.revthe commit a dependency is pinned to, or "" when it is a hub package
- def source.tagthe tag a dependency was asked for, or "" when it was pinned by commit
- def source.urlthe repo a dependency was vendored from, or "" when it is a hub package
- def source.rootthe directory inside the checkout a dependency's paths are written from
- def source.narthe NAR hash nix rebuilds a dependency's checkout by
- def source.nvthe `<name>@<version>` a hub dependency was added by, or "" for one added by its hash, and for a git one
- def source.is_gitwhether a dependency names a repo rather than the hub
- def source.vendorwhether an upgrade that moves this dependency also commits the new tree
- def source.depthe source of a dependency that was found
- def rev_ofthe commit the named dependency is pinned to
- def tag_ofthe tag the named dependency was asked for
- def hub.orthe hub a ledger's packages come from: the `hub` its `[package]` table names, or bend's own when it names none.
- def hub_ofthe hub of a ledger that was read.
- def tools_ofthe pinned CLIs of a ledger that was read; one that would not parse has none
- def tool.find.pickthis tool when its name matches, otherwise whatever the rest gave
- def tool.find.atthe tool of this name, or a blank one
- def tool.findthe tool of this name, or one with empty fields
- def tool.stepthe rest of the scan only when this one was not it
- def tool.haswhether the ledger pins a CLI of this name
- def tool.known.goan empty `--package` is every tool; a name is that one
- def tool.knownwhether `--package` names a pinned CLI, or names nothing and so names all
- def linea key line, or nothing at all when the value is empty, so an absent tag, entry or bin leaves no trace
- def line.barea key line whose value is written bare, as a TOML boolean is, or nothing at all when the value is empty
- def vendor.word`true` when the tree is committed, and nothing when it is not, so the key is absent rather than written as an empty string.
- def sourcethe keys a source contributes
- def depone `[deps.<name>]` section
- def depsevery dependency, in the order the ledger holds them
- def toolone `[tools.<name>]` section.
- def toolsevery pinned CLI, in the order the ledger holds them
- def textthe ledger as ez assembles it, in the TOML ez wrote before eztoml 0.4
- def showthe ledger as an ez.toml: ez's text, written as eztoml writes it
- def rendera ledger that was read, as an ez.toml; an unreadable one renders as nothing, so a failed read can never overwrite a good file with a guess
- def without.puta dependency kept or dropped
- def withoutevery dependency but the one named
- def addthe ledger with a dependency added, replacing any of the same name, so adding twice is the same as adding once
- def removethe ledger with a dependency dropped
- def vendoreda git source with its tree committed
- def revenda source that keeps a vendor bit the ledger already set, or is left as given
- def readda dependency added again keeps the `vendor = true` its entry already had.
- def add.keepthe ledger with a dependency added, keeping the vendor bit of the entry it replaces
- def clearwhether a text holds no copy of a char
- def cleanwhether a name or value can be written as it is: it holds no `"`, no `\` and no newline.
- def source.okwhether a source reads back as itself.
- def hash.okwhether a dependency's hash can be written: one is there, which the reader asks every dependency for but a workspace member's, whose ledger records none and whose hash only the joint ledger gives
- def dep.okwhether a dependency does: it has a hash, but for a workspace member, and every name and value is clean
- def deps.okwhether every dependency does
- def tool.src.okwhether a pinned CLI's source does.
- def tool.okwhether a pinned CLI does
- def tools.okwhether every pinned CLI does
- def renderablewhether a ledger can be written so that it reads back as itself (EZ-LED-4): every name and value is clean, `publish-as` and `version` among them, every dependency has a hash, and every git source names its repo and its root.
- def unrenderablewhy a ledger that is not renderable is not written
- type Aimwhat an upgrade will ask the remote, once the ledger has been read
- type Verdictwhat that answer means for the pin
- type Swapone hash that moved, and the hash that replaces it: an import line to rewrite, or a committed tree to remove
- def chosen.goan empty `--package` is every dependency; a name is that one
- def chosenan empty `--package` is every dependency; a name is that one
- def known.stepthe rest of the scan only when this one was not it
- def known.inwhether the ledger names this dependency
- def known.go`--package` with no such dependency is a mistake, and no filter is not
- def knownwhether the ledger names the dependency `--package` asked for
- def aim.taga selected git pin with no tag follows the default branch
- def aim.srca selected hub pin has nothing to follow
- def aimwhat this dependency is asked.
- def judge.samethe same commit either still hashes to the pin or it does not
- def judge.movea different commit is the upgrade only when it descends from the pin
- def judge`same` is the resolved commit against the pin.
- def agree.narthe three fields a checkout can disagree on, each required
- def agree.gowhether a recomputed pin is the one the ledger already recorded
- def agreewhether a recomputed pin is the one the ledger already recorded
- def hub.bada hub miss is a different digest only when the body arrived and hashed wrong.
- def retarget.gothe dependency with a new commit written in, and the name, the entry, the tag and the vendor bit left as they were
- def retargetthe dependency with a new commit written in
- def reimport.headwhat an import line that names a package starts with: `import <hash>/`.
- def reimport.hitan empty hash names no package, so it rewrites nothing
- def reimport.line.goone line, with the branch already chosen.
- def reimport.lineone line, with its import hash rewritten when the line names the old one
- def reimport.many.lineone line through every replacement, in order
- def reimport.many.linesevery line, in order
- def reimport.manya source file with every moved import hash replaced, in order.
- type Srcwhere a package's bytes come from.
- type Packa package the lock records
- type Origina package's origin, as ez.toml records it
- type Namea `<name>@<version>` and the `0x` name it names.
- def spec.hashthe `0x` name an import carries, which is everything before its first `/`
- def spec.putan import's package, or nothing when it names a module of this project
- def specsevery package a list of imports names
- def kidsevery package the sources of one package import
- def named.putan import's `<name>@<version>`, or nothing when it names no package by name.
- def namedevery name a list of imports names
- def kids.namedevery name the sources of one package import
- def name.atthe hash this name names when it is the one looked for, otherwise the rest's.
- def name.findthe hash a table of names gives a name, the first it records for it, or "" when it records none
- def name.puta name's hash, or nothing when the table does not resolve it
- def name.hashesthe hashes a table gives a list of names, leaving out the ones it does not resolve
- def kids.inevery package the sources of one package import, by hash and by a name the table resolves
- def name.onea name with the hash the table gives it, or nothing when it gives none
- def name.pairseach name the table resolves, with its hash; one it does not is left out
- def hex.charwhether a hash is a package's `0x` name as bend reads one out of a names file: `0x` and 32 lowercase hex digits
- def hex.all
- def hash.ok