ezx

Search uses release 1.11.0.0 · 2,947 definitions

Releases (9)

1.11.0.0 indexed
1.10.0.0 unindexed
1.9.0.0 unindexed
1.8.0.0 unindexed
1.7.0.0 unindexed
1.6.0.0 invalid
expected a fresh constructor name (duplicate declaration: Text)

at src/lock/up.bend:121
19 files do not load
expected a file at https://hub.bend-lang.com/0x49ec536f1d3da4f76d78aaece3ccda7a/manifest hashing to 49ec536f1d3da4f76d78aaece3ccda7a

at src/hub/get.bend:7
12 files do not load
1.5.0.0 invalid
expected a fresh constructor name (duplicate declaration: Wait)

at src/add/hub.bend:87, src/pub/plan.bend:1080, src/tool/plan.bend:867
10 files do not load
1.4.0.0 invalid
expected a fresh constructor name (duplicate declaration: Wait)

at src/add/hub.bend:87, src/pub/plan.bend:1080, src/tool/plan.bend:867
10 files do not load
1.3.0.0 unindexed

Definitions (2,947)

src/add/world.bend

def targetthe target asked for
def refthe ref asked for, "" for none
def entry.arg
def renamethe `--rename` asked for, "" for none
def herethe directory ez runs in, which is the project root
def homeHOME, which a `~/` target is expanded against
def ledgerthe ledger's text, None when there is no ez.toml
def ignore`.gitignore`'s text, "" when there is none
def repliesevery question answered so far
def hubsevery hub question answered so far
def read.ofthe ledger as read: what the file says, or, with no file, a read that did not parse and says why.
def readthe ledger, read
def manifest.ofthe model of a ledger that read; an empty one otherwise, which nothing writes, since a ledger that did not read is refused
def deps.ofthe dependencies of a ledger that was read
def depsthe ledger's dependencies, none when it did not read
def placewhere the target names
def url.ofthe source a place records: a URL as it is, a path as it was given with a leading `~/` expanded against HOME, and nothing for a target that names nothing
def urlthe source the ledger records (EZ-LED-8)
def fromthe source as git is to read it: a relative path taken from where ez runs, which is the project root.
def freshthe name the source gives itself: a repository's, or the directory's the path resolves to
def aimwhat the target names: a hub package by its `<name>@<version>`, or a place
def namedwhether the target is a hub package's `<name>@<version>`
def hubthe hub the ledger names, which a name and its package are asked of

src/doctor/plan.bend

type Noteone thing doctor looked at: what to print, and whether it is a problem
def plurala count with its noun, kept in agreement
def answeredthe lines a run printed, or none when it failed, so a program's complaint on stderr is never mistaken for an answer
def banner.ofthe first line of what a program printed
def bannera version banner, which is one line however many a program prints
def probe.notewhat a version run said about the program it ran
def probe.answerwhat the answer to a version question says
def probe.hearda program's line, once it was asked
def cc.namethe C compiler the native lane will use: `$CC` when it is set, else `cc`.
def programsthe programs doctor asks for their versions.
def probesevery program's line
def deps.ofthe dependencies of a ledger that was read
def deps.counthow many dependencies a ledger names; one that did not read names none
def ledger.notewhat the ledger turned out to be
type Lockedwhat the lock turned out to be: the packages it records, or why it could not be read, or no lock at all
def locked.pickthe verdict on a parse, with the answer in hand
def locked.parseda lock that parsed, by the packages it records; one that did not, by why
def locked.ofthe lock's text, read
def locked.hashesthe packages a lock records; none when it did not read or is not there
def lock.needswhether a ledger with this many dependencies needs a lock that names some
def lock.wrongwhether the lock is a problem: it names no package while the ledger has dependencies it should have resolved.
def lock.notewhat the lock amounts to.
def lib.atwhere the packages this build resolves against live.
def lib.havethe names `ls` gave for the library, none when it gave none
def has.stepthe rest of a scan only when this one was not it.
def haswhether a list holds this string
def missing.puta string kept when the other list lacks it
def missingthe strings of `xs` that `known` does not hold
def lock.namesthe names the lock records, with the hash each names; none when there is no lock, or when it does not read
def name.heldwhat a name's file says against the lock: nothing when it holds the lock's hash, as bend trims it, and the fault otherwise
def name.got
def name.heard
def names.wrongevery name of the lock whose file under BEND_LIB is missing, or names another hash than the lock does, which bend would read instead of asking the hub
def names.saidwhat the library holds of the lock's names, said after its packages
def lib.faultswhat is wrong with the library, each fault in its place
def lib.saidBEND_LIB judged against the lock: every package the lock names has to be on disk, because bend resolves a hub import during the check and a sandbox has no network to fall back on, and so does every name's file, since bend would otherwise ask the hub what the name names
def lib.judgethe verdict, once what is wanted and what is there are both known
def lib.notethe library's line
def once.puta head kept when the rest does not hold it again
def onceevery string of a list once, each where it last stands
def importsevery hub package the project's sources import, each once, by hash and by name.
def pinned.ata dependency's name, when the ledger records it by one
def pinned.nv
def pinnedthe hashes a ledger's dependencies name, and the names it records them by
def usedwhether an import line names a dependency, by its hash or by its name
def unrecorded.linehow a hash imported and not in the ledger reads
def unrecordedevery hash imported that the ledger does not name
def unused.linehow a ledger entry nobody imports reads
def unused.puta dependency reported when nothing imports it
def unusedevery dependency of the ledger that no import line uses
def driftboth directions of the disagreement: a hash the source imports that the ledger never names, and a ledger entry no import line uses
def flagevery line of a report, each a problem
def drift.notesthe report, or the one line that says there is nothing to report
def listing.notesthe report over what git listed, or why it could not list
def sources.notesthe report, once the sources were asked for
def imports.notesthe report over a ledger.
def tree.howhow a tree read from BEND_LIB arrived, as the lock judges it.
def ask.srcthe source a lock question names
def tree.puta tree BEND_LIB held, as the answer the lock reads, ahead of the rest.
def tree.replya reply kept when it answers a lock question
def treesevery tree BEND_LIB held, as the lock's answers
def lock.textthe lock's text, "" when there is none, as the lock's own question reads it
def name.puta name's file BEND_LIB held, as the answer the lock reads for the name, ahead of the rest.
def name.replya reply kept when it answers a name's question
def heldevery name's file BEND_LIB held, as the lock's answers
def relock.worldthe World doctor puts to the lock planner: a plain lock over the ledger's text as it is, the sources as git listed them, the lock as it is, which answers the lock's question about the names it records, every tree BEND_LIB held, and every name's file it held, never the network.
def relockthat World, over the sources as a list of files
def fresh.linethe line for a lock `ez lock` would write as it is
def stale.linethe line for one it would write otherwise
def fresh.saidthe verdict, once the two texts were compared
def fresh.docthe lock against what the lock planner decided: the text it would write, or why it would write none
def ask.hashesthe hashes of lock questions
def fresh.namedthe lock, once every name the lock planner asks about is known: when none is left, what it decided; when some are, their files are not under BEND_LIB, and doctor does not ask the hub for them
def fresh.awaythe lock, once every question the lock planner asks is known: when none is left, its names, then what it decided; when some are, they are about packages BEND_LIB does not hold, and doctor does not ask the network for them
def fresh.listingthe check over the sources git listed.
def fresh.heardthe check, once the sources were heard.
def fresh.notesthe check over a lock that is there.