ezx
Search uses release 1.13.0.0 · 2,947 definitions
Definitions (2,947)
- def name.textthe text of the file bend reads a name's hash from, `$BEND_LIB/names/<nv>`
- def name.valida name kept when the hub rules it in and it names a `0x` hash, since that is the only pair bend would read back
- def names.valid.pick
- def names.validthe names of a list that bend would read back
- def segsa table's path, as segments
- def is3whether a table's path is these three segments
- def named1whether a table's path is one segment, this one
- def named3whether a table's path is three segments, headed and tailed by these, whatever the hash between them is
- def at.pickthe pairs of a table when it is the one asked for, otherwise the rest's
- def at3the pairs of the table at this three segment path, or none
- def src.membera member's origin keeps its directory and entry; anything else is the hub
- def src.goa git origin keeps every key it was written with
- def src_ofwhere a table says a package's bytes come from
- def ledger.othera dependency that is not a git one as an origin: a workspace member's tree, which only the joint ledger names, or the hub
- def ledger.puta ledger's dependency as an origin: the repo and rev it names, or the hub.
- def ledger.originsevery origin a ledger's dependencies record, in the order written
- def ledger.readevery origin a ledger records.
- def ledger.namea dependency's name, when the ledger records it by one
- def ledger.names.ofevery name a ledger's dependencies record, each with the hash it named when it was added
- def ledger.namesevery name a ledger records.
- def origin.atthis origin's source when the hash matches, otherwise whatever the rest gave
- def originwhere a package comes from, which is the hub unless an origin says otherwise
- def origin.hashthe hash an origin is recorded under
- def line.putone `<sha256> <path>` line of a manifest
- def manifest.filesevery file a manifest names
- def url_ofa url under the hub
- def wantbend accepts any prefix of the sha256, and a package's `0x` name is the first 32 characters of its manifest's digest
- def nar.why.gowhy a fetched checkout is not the one the ledger pins, or "" when it is.
- def nar.why
- def pack.hashthe hash a package is recorded under
- def any.stepone step of a scan that is looking for one hit.
- def knownwhether the ledger names a package.
- def haswhether a package is already resolved.
- def seen.holdswhether a name is already among the ones a walk has seen.
- def kva key worth writing, or nothing at all when its value is empty, so an absent tag leaves no trace
- def src.pairsthe keys a source contributes to the lock
- def file.paira file of a package as a `"<path>" = "<sha256>"` pair
- def file.pairsevery file of a package, in path order
- def pack.sects.ofthe two tables a package is written as, from its files already in path order and each one once
- def pack.sectsthe two tables a package is written as
- def pack.allevery package, in hash order
- def pack.lepackages are written in hash order, so a lock is the same text however it was resolved
- def pack.ins.putwhere a package goes among the packages already in order.
- def pack.insa package inserted into a list already in hash order
- def pack.sortthe packages in hash order.
- def lock.sectthe `[lock]` table: what resolved the lock.
- def docthe lock as a document: what resolved it, then every package it resolved, in hash order.
- def pack.blocka package's two tables as one block of text, filed under its hash.
- def pack.blocksevery package, as its block
- def block.textsthe text of every block, in the order given
- def text.ofthe lock's text: the `[lock]` table, each block in the order given, then the rest, assembled as ez's document text (`T.render`) and written as eztoml writes it (`T.normal`).
- def renderthe lock as the text written to ez.lock.toml, its packages in hash order
- def tool.pairsthe keys a pinned CLI contributes.
- def tool.sectone `[tools.<name>]` table
- def tool.sectsevery pinned CLI, in the order the ledger holds them
- def render.toolsthe lock with its tools after the packages.
- def name.filea name as the pair the `[names]` table writes it as, which is the shape a file of a package is written in: its `<name>@<version>` as a quoted key and its hash as the value
- def name.filesevery name, so
- def names.sectsthe `[names]` table: every name the lock resolved, in name order and each once, sorted and deduplicated the way a package's files are.
- def render.namesthe lock with its names and then its tools after the packages
- def render.pickthe same, told whether the tool list is empty
- def lock.pairsthe `[lock]` table of a lock that was read
- def lock.hubthe hub a lock was resolved against
- def names.pairsthe `[names]` table of a lock that was read
- def pair.namea pair of the `[names]` table as a name
- def pair.namesevery pair of the `[names]` table, as names
- def namesevery name a lock records, in the order its table holds them
- def names.readevery name a lock's text records that bend would read back.
- def hash.putevery hash a lock records, one per `[packages."<hash>".files]` table
- def hashesevery hash a lock records
- def pair.filea pair of a files table as a file
- def pair.filesevery pair of a files table, as files
- def pack_ofthe package a lock records under this hash
- def packs.atevery package a lock records
- def packsevery package a lock records
- def pack.srca package's source
- def pack.filesa package's files
- def pack.manifestthe manifest text a package is served with
- def src.kindwhere a package comes from, in a word
- def src.revthe commit a package is pinned to, or "" when it comes from the hub
- def src.urlthe repo a package was vendored from, or "" when it comes from the hub
- def src.rootthe directory inside a checkout a vendored package's paths are written from
- def src.narthe NAR hash nix rebuilds a vendored package's checkout by, or "" when it comes from the hub
- type Looka verdict looked up, or none when nothing has been asked about the hash yet
- def look.atthis verdict when it is the hash asked for, otherwise the rest's
- def lookthe first verdict recorded for a hash
- type Walka walk in progress: the hashes still queued, the packages resolved, the hashes still to be asked about, and the first refusal, "" while there is none.
- def firstthe first refusal wins
- def step.verdictone package, by its verdict.
- def step.lookone package, asked about when nothing has answered for it yet
- def step.picka hash already resolved, or already asked about, is passed over
- def step.popthe next hash of the queue, or the walk as it is when the queue is empty
- def walk.stepone step of the walk
- def walk.donewhether a walk has nothing left in its queue
- def walk.spenta walk that ran out of fuel with its queue not empty, refused
- def walk.morethe walk as it is when it is done, or one step further when it is not.
- def walk.outthe fuel ran out: refused, unless the walk had just finished
- def walkevery package the queue reaches, each one once.
- def walk.packsthe packages a walk has resolved
- def roots.oneevery hub package one committed source imports.