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/plan.bend

def decide.readno ledger, or one that does not parse, is refused before anything else, with the reason every command that edits a ledger gives
def decidewhere a World stands before the walk
def dep.ofthe dependency recorded, from the walk's hash and root
def outcome.fitthe ledger with the package added, once it is known to read back.
def outcome.namethe name, once the walk made a package, then the ledger it leaves
def outcome.walkthe walk's verdict: a package, or why there is none
def outcome.entrythe entry has to be in the checkout for there to be a package to walk
def outcome.khow an add over an answered World ends, given its walk
def added.kthe dependency the plan records: the one `dep.of` makes from the walk, or an empty one when the walk made none, which no plan writes
def addedthe dependency `ez add` records on a World
def ledger.nextthe ledger `ez add` leaves on a World
def src.ofa found file as it is laid
def srcsevery found file as it is laid
def place.ofwhere the tree is laid: under `.ez/lib`, committed, when the entry it replaces is vendored, since the re-added entry keeps that bit; under BEND_LIB otherwise
def any.stepthe rest of a scan only when this step was not the hit
def holdswhether a dependency names this hash
def char.okwhether a char may stand in a hash that names a directory under `.ez/lib`
def chars.ok
def safea hash `rm -rf .ez/lib/<hash>` removes one tree for, as `ez remove` checks it: a `0x` name with no path separator in it
def gonethe committed tree a re-add moves off: the old hash of a vendored entry when the hash moved, it is safe to remove, and nothing left names it
def ignore.put`.gitignore` written ahead of the rest when the allowlist changes it
def at.ofthe entry's path inside a package rooted at `root`, which is where the hub serves it: its name alone, unless an import climbs out of its directory and re-roots the package above it
def saysthe lines a person is told: the commit a tag or branch turned out to be, and the import line the package is now reachable by, for the entry at `at` inside it.
def effects.ofwhat an add that walked a package does: the tree laid, ez.toml written, `.gitignore` when the allowlist changes, the old committed tree removed, and what a person is told
def effects.kthe effects of an add whose walk made a package; none otherwise
def seala plan that refuses has no effect at all; its reason is how it ends
def madethe plan once every answer is in, with `k` the walk.
def plan.vthe plan for where the World stands.
def plan`ez add` over a World
def refuses.planwhether a plan ends in a refusal
def refuseswhether `ez add` refuses on a World
def qs.vthe questions still open where the World stands
def wantsthe questions a World still leaves open, each about the anchored source
def answeredwhether every answer the planner needs is in
type Stepthe questions still open, or the plan once there are none
def step.v
def stepwhat the interpreter does next on a World
def resolves.onewhether a question asks the remote to resolve a ref: its tags, its HEAD, or a named ref.
def resolveswhether any question does
def ask.urlthe source a git question names, "" for any other question
def asks.fromwhether every question names this source
def afterwhat a path holds once a plan has run, when it held `was` before
def hash.ofthe hash of the package the walk made, "" when it made none
def root.ofthe directory its paths are written from, "." when it made none
def hashthe package's hash on a World
def atthe entry's path inside the package on a World, which is where the hub serves it
def last.gothe last of some lines, `prev` when there are none after it
def lastthe last line a plan says, "" when it says none
def command.ofthe plan `ez add` runs, once it is known whether the target is a name
def commandthe plan `ez add` runs on a World
def refuses.commandwhether `ez add` refuses on a World
type Nextwhat the interpreter does next: answer git's questions, answer the hub's, or run the plan
def next.gitthe git planner's step
def next.hubthe hub planner's step: its questions, or its plan once there are none
def next.of
def nextwhat the interpreter does next on a World
def next.askswhether a step still asks anything

src/add/relock.bend

type Worldwhat `ez add` reads: the add's World, the `.bend` files git lists, and the answers to the lock's questions
def addthe add's World
def found.pickthis file's text when it is the one at the path, else the rest's.
def text.atthe text of the file at a path among a walk's files, "" when none is there
def textsthe text of each file a manifest names, in its order
def seed.ofthe package a walk made, as the answer to the lock's question about its hash: its manifest and the text of each file it names, read as a tree under BEND_LIB, which is where the add lays it.
def seeds.ofthe answers the add already has for the lock: a hub package's are those the hub gave the add, and a git package's is the package its walk made
def seedsthe answers the add already has for the lock, on the add's World
def lock.worldthe World a plain `ez lock` reads once the add has run: the ledger it writes, the `.bend` files git lists, and the answers it was given, the add's first
def lockthe plan of that lock
def added.ofthe hash of the package the add records
def addedthe hash of the package the add records, on the add's World
def heldwhether the lock holds a package under the hash
def unlockedthe line that says the lock does not hold it
def notes.ofthe note: the line when the lock does not hold the package, none when it does
def notesthe note on a World
def moved.ofwhat is added after the lock's reason when the lock refuses: that nothing was written, and, when the add moves a dependency's hash, where the old one may still be imported from
def tail.dep
def dep.ofthe dependency the add records
def tailwhat is added after the lock's reason, on the add's World
def plan`ez add` over a World: the add, then the lock over what it leaves
def refuseswhether `ez add` refuses on a World
type Nextwhat the interpreter does next: answer git's questions or the hub's for the add, answer the lock's, or run the plan
def next.lockthe lock's step, once the add is planned and succeeds
def next.madethe add's plan made: refused, it is the plan; otherwise the lock is next
def next.add
def nextwhat the interpreter does next on a World

src/add/run.bend

def morethe World with more answers in it
def more.hubthe World with more of the hub's answers in it
def more.lockthe World with more of the lock's answers in it
def loop.stepthe planner's step: its questions answered and the loop gone round again, or its plan run
def roundsthe rounds the loop may take.
def loopthe loop, under fuel.
def run`ez add <target> [ref] [entry.bend] [--rename NAME]`

src/add/world.bend

type Argswhat `ez add <target> [ref] [entry.bend] [--rename NAME]` was given, each "" when it was not
type Worldeverything `ez add` reads
def tomlthe ledger's path, which is fixed
def ignore.filethe ignore file's path, which is fixed
def argsthe arguments
def args.target
def args.ref
def args.entry
def args.rename