ezx
Search uses release 1.13.0.0 · 2,947 definitions
Definitions (2,947)
- def rootsevery hub package the committed sources import.
- def roots.named.oneevery name one committed source imports, outside `.ez/`
- def roots.namedevery name the committed sources import.
- def tablethe table of names a lock resolves names by: those ez.toml records, each with the hash beside it, first, then those the answers resolve, the lock being rewritten's before the hub's
- def fuel.verdicthow many imports one verdict queues: a package's, or none
- def fuel.judgedhow many imports every verdict queues between them
- def walk.fuelhow many steps the walk may take: one for each hash the queue starts with, one for each import a verdict can queue, since a hash is resolved at most once, and one more to spare.
- def walk.ofthe walk from every committed source: every package they import by hash, and every one they import by a name the table resolves.
- def listing.filesthe committed sources a listing holds, none when git could not list them
- def pack.srcsthe texts of a package the walk resolved, as its verdict holds them
- def packs.namedevery name the packages a walk resolved import
- def neededevery name a lock needs resolved: those the committed sources import, then those the packages it reaches import
- def need.whywhy a plain lock cannot copy the ledger's tool pins, or "" when it can.
- def char.bada char the lock's TOML cannot carry inside a quoted key or value: eztoml neither writes nor reads escapes
- def cleanwhether a key or value can be written as it is
- def clean.allwhether every string in a list can be written as it is
- def src.valuesevery value a package's source writes
- def file.valuesevery path and sum a package's files write
- def pack.valuesevery hash, key and value a package writes
- def path.eqlesswhether a file path holds no `=`.
- def paths.okwhether no file path of a package holds `=`
- def packs.okwhether every package can be written, and no hash is written twice
- def tool.valuesevery name, key and value a tool pin writes
- def tools.okwhether every tool pin can be written
- def lockablewhether a lock can be written so that it reads back: every hash is written once, no hash, key or value holds `"`, `\` or a newline, and no file path holds `=` (eztoml#24, above).
- def path.eq.pickthe first path among a package's files that holds `=`, or "" when none does.
- def path.eq.first
- def path.eq.whywhy a package with such a path cannot be locked, naming it and the path
- def packs.eq.pickthe reason for the first package with such a path, or the rest's
- def packs.eqwhy the first package with a path holding `=` cannot be locked, or "" when no package has one
- def lockable.pickthe reason a lock that is not `lockable` gives: the package and path when a path holds `=`, which is the one case a clean-looking lock hides
- def lockable.why
- def names.okwhether every name the lock records can be written so that it reads back: a name is written as a quoted key and its hash as a value, the way a package's file is, so it is held to what a file is held to
- def lockable.namedwhether a lock with names can be written so that it reads back
- def lockable.why.pickthe reason a lock with names that is not lockable gives
- def lockable.why.named
- def names.missing.picka name, when it is the first the search wants, or the rest's
- def names.ruledthe first name of a list the hub rules out, or "" when it rules them all in
- def names.missingthe first name of a list the table does not resolve, or "" when it resolves them all
- def names.open.whywhy a name nothing resolved stops the lock: what its answer said, or that it was never asked
- def names.unledgered.whywhy a name the project imports and ez.toml does not record stops the lock
- def why.then.ata reason, or when there is none the next one, looked at only then
- def why.then
- def why.missing.atno reason when no name is at fault, and the fault's otherwise
- def why.missing
- def names.whywhy the names a lock needs stop it, or "" when they do not: a name the hub rules out, as bend refuses it; a name the project imports that ez.toml does not record, which is the lock's own rule, since only a dependency ez.toml records vouches for where a name came from; and a name nothing resolved
- type Docwhat a plain lock decides: the text of ez.lock.toml, or why it refuses
- def doc.lockablea lock that can be written, written, with the names it resolved
- def doc.asksa walk with nothing left to ask is the lock.
- def doc.namedthe names settled: a name that stops the lock stops it, and otherwise the lock records each name it needed with the hash the table gives it
- def doc.bada refusal wins over everything after it
- def doc.walkthe walk's result
- def doc.gapa tool pin a plain lock would have to fill stops it before the walk counts
- def decide.ledplain `ez lock` over a parsed ledger
- def decide.stopan upgrade that refused, or still asks, stops the lock before anything else
- def decide`ez lock` over what the lock may depend on
- type Placewhere a package is laid: `.ez/lib`, which is committed for a vendored dependency, `$BEND_LIB`, which is a cache, or `<dir>/.ez/lib`, the committed trees of the workspace root at `dir`, where `ez add` and `ez remove` in a workspace lay the root lock's (ws/relock.bend)
- type Effectone thing the interpreter does.
- type Outcomehow the command ends: exit 0, or exit 1 with the reason
- type Planthe effects, in order, and how the command ends after them
- def statusthe status a command exits with (EZ-OUT-1): 0 when it succeeds, 1 when it refuses.
- def status.ofthe status of a command that refused, or did not
- def whywhat a command that ends is said to have ended on: nothing when it succeeded, and the reason when it refused
- def codethe status a plan ends with
- type Queryone of the upgrade's questions, as the upgrade looks its answer up (`ask`, with the source the ledger records) and as git is asked it (`git`, with that source anchored at the directory the lock runs in, `Up.anchor`).
- type Stepthe questions still open, the lock's and the upgrade's, or the plan once there are none.
- type Wrotewhat a plan leaves at one path: nothing written, or this text
- def lockfilethe lock's path, which is fixed
- def cloned.howevery hash a clone answered: those are the trees a lock lays under BEND_LIB for the build that follows
- def cloned.one
- def clonedevery hash a clone answered, in the order they were answered
- def place.ofwhere a tree is laid: under `.ez/lib`, committed, when the ledger the lock is made from vendors its hash, and under BEND_LIB otherwise
- def lay.verdicta checked tree laid, ahead of what follows: its files with their texts, then the manifest of those texts, which is the manifest whose name the verdict checked (`W.body.laid`)
- def lay.pick
- def laysevery cloned tree that passed its checks, laid ahead of what follows.
- def names.laya names file for every name a lock records, ahead of what follows, so bend reads each name's hash from BEND_LIB and never asks the hub for it
- def says.ofthe lines a person is told, ahead of what follows
- def said.inthe lines a list of effects says, in order
- def saidthe lines a plan says, in order, which is what a person is told
- def edits.ofthe files the upgrade writes, in order, ahead of what follows
- def drops.ofthe committed trees the upgrade moved off, removed ahead of what follows
- def madethe plan for what was decided.
- def plan.of`ez lock` once the upgrade decided: every package checked once, and the plan
- def plan`ez lock` over a World
- def refuses.docwhether what was decided is a refusal
- def refuseswhether `ez lock` refuses on a World
- def packs.ofthe packages `ez lock` resolves once the upgrade decided
- def packsthe packages `ez lock` resolves on a World, which are the packages its lock renders when it writes one
- def ledger.nextthe ledger model an upgrade renders into ez.toml; ez.toml as it was when the upgrade refuses, still asks, or moves nothing, and for a plain lock.
- def put.oneone effect's part in what a path is left holding, with what the effects after it leave already known.
- def put.inwhat a list of effects leaves at a path
- def put.planwhat a plan leaves at a path
- def putthe bytes `ez lock` writes to a path on a World, or Kept when it writes none
- def writes.onewhether an effect writes, lays or removes anything
- def writes.inwhether a plan writes, lays or removes anything
- def writeswhether a plan writes, lays or removes anything at all
- def frontevery file of a tree but the last, which a `Lay` writes as the manifest
- def text.ofa file's text
- def lastthe last file's text, "" for no file
- def lay.namedwhether a laid tree is named by the manifest of the texts it lays: its last file is the manifest of the others, each weighed by its own text, and its hash is the `0x` name of that manifest