ezx

Releases (11)

• 1.13.0.0 indexed
• 1.12.0.0 unindexed
• 1.11.0.0 unindexed
• 1.10.0.0 unindexed
• 1.9.0.0 unindexed
• 1.8.0.0 unindexed
• 1.7.0.0 unindexed
• 1.6.0.0 unindexed
• 1.5.0.0 unindexed
• 1.4.0.0 unindexed
• 1.3.0.0 unindexed

Definitions (2,947)

src/ws/moved.bend

• def atthe first member written from a directory, or none
• def hash.ofa member's hash, or "" for none
• def move.puta move kept, once it is known whether it is one
• def move.foundthe member the lock records at a directory, against what it is now: it moves when its hash is not the one the lock records, and it is chosen (`--package`, or every member when none is given) or its hash is not the one it had before any line was rewritten, which is a member whose files the upgrade rewrote
• def movesevery member the lock records that moves: `now` the members as they are, `base` as they were before any line was rewritten
• def swapsthe moves as the rewrites they make
• def rewriteevery committed file with every moved hash rewritten
• def stale.moveswhy a file stops a plain lock: the first move one of its lines names
• def stalewhy a plain lock refuses: the first committed file with a line naming a moved member's recorded hash, "" when none does
• def now.readthe members of a ledger's text, as the joint ledger renders them
• def now.ledgerand of the World's ledger
• def movedevery member that moved since the lock being rewritten, against the joint ledger the lock is planned from
• def stale.worldwhy a plain lock at a workspace root refuses before it asks anything, "" when it does not
• def move.eqwhether two moves are one
• def moves.eqwhether two lists of moves are one
• type Ctxwhat a round of the upgrade sees: the root's ledger text, every other ez.toml git lists, the committed files as they are, the members the lock records, the members before any line was rewritten, and `--package`
• def roundthe moves the next round makes: the files rewritten with this round's moves, the members walked again over them, and the moves against those
• def cascade.pickthe moves once a round is known to change them or not; the rounds after it arrive as a thunk, so the rounds stop where the moves do
• def cascade.gorounds, under fuel, until one moves no member further
• def ctxthe context of an upgrade's rounds
• def cascadethe members the upgrade moves, from the ones it is asked to.
• def edit.puta rewritten file written, when the rewrite changed it and it is not the lock
• def editsevery file the moves rewrite, written
• def sourcesthe committed files as the lock is to read them
• def world.movedthe World the upgrade plans on: the committed files rewritten with every move, and the joint ledger and the answers for its members made again over them, so the lock walks the members as the rewrite leaves them

src/ws/pin.bend

• type Refthe ref an add goes on with, or why it stops
• def heldthe ref the workspace pins a source at: its tag, or its commit when it has no tag
• def ref.pinneda ref given against the pin the workspace records for the source
• def ref.ata ref given against what the workspace records for the source, if anything
• def ref.placea place's ref: a git source's against the workspace's pins, as the root reads the source from the member's directory, and anything else as given
• def refthe ref `ez add <target> [ref]` in a member goes on with: `pins` is every dependency of the workspace's joint ledger and `dir` the member's directory from the root.

src/ws/relock.bend

• type Rootedwhat a command run in a workspace reads of its root: the root's directory, the path from it to where the command runs, the root's ledger, every other ez.toml git lists under it, the `.bend` files git lists under it, each path from the root, and the root's lock
• type Wswhere a command runs: in a project of its own, or in a workspace
• def rooted.atthe root's directory
• def at.placea place a tree is laid in, taken from the root: the root's committed `.ez/lib` for a committed tree, BEND_LIB as it is, and a directory under the root from the root
• def at.effectan effect of the root's lock as it is run from where the command runs: every path it writes taken from the root.
• def at.effectsevery effect of the root's lock, so
• def at.planthe root's lock plan, so
• def keep.parseda ledger the command writes at the root, once it is read: as the root's with the table it had, or as it is when it does not read
• def keep.readonce it is known whether the root's ledger, `old`, had a `[workspace]` table
• def keepthe text a command writes as the root's ledger, which held `old`
• def keep.writea file the command writes, once it is known whether it is the ledger
• def keep.effectan effect of the command at the root, its ledger keeping its table
• def keep.effectsevery effect of the command at the root, so
• def edit.atthe command's own plan, run at the path `rel` from the root, whose ledger is `old`: at the root, with the root's ledger keeping its table, and in a member as it is
• def editthe command's own plan, in the workspace
• type Ledgersthe root's ledger and every other ez.toml git lists under the root
• def put.picka listed ez.toml, once it is known whether it is the one the command writes
• def put.foundevery listed ez.toml, the one at `path` holding `text`
• def ledgers.atthe ledgers once the command at `rel` writes `new`: the root's, at the root, or the member's ez.toml under it
• def new.ofthe ledger's text the command leaves, "" when it leaves none, which only a command that refuses does
• def ledgersthe ledgers the command leaves, when its own plan, as the workspace runs it, is `pl` and its ledger held `was` before
• type Lockthe lock at the root, as a plain `ez lock` there plans it: what its upgrade half needs and the World it reads, or why the ledgers cannot be joined
• def worldthe World a plain `ez lock` reads at the root
• def lock.jointthe lock, once the ledgers were joined: as `ez lock` at the root reads it (ws/run.bend's `joint.at`), with the members' answers first
• def lock.readthe lock, once the root's ledger is read
• def lock.ofthe lock at the root over the ledgers the command leaves
• def stopa refusal, with no effect
• def lock.planthe lock's plan
• def lock.stepthe lock's step
• def lock.packsthe packages the lock records, none when it cannot be made
• def add.editthe add's own plan, as the workspace runs it
• def add.lockthe root's lock over what the add leaves, with the answers the add has for it first
• def add.notesthe note (EZ-DOC-7), over the root's lock
• def add.plan`ez add` in a workspace: the add, then the root's lock over what it leaves, run from where the add runs
• def add.next.lockthe lock's step, once the add is planned and succeeds
• def add.next.madethe add's plan made: refused, it is the plan; otherwise the lock is next
• def add.next.addthe add's own step: its questions, or its plan made
• def add.nextwhat the interpreter does next for `ez add`: in a project of its own, what add/relock.bend says; in a workspace, the add, then the root's lock
• def add.planned`ez add`'s plan, wherever it runs
• def remove.editthe remove's own plan, as the workspace runs it
• def remove.lockthe root's lock over what the remove leaves
• def remove.plan`ez remove` in a workspace: the remove, then the root's lock over what it leaves, run from where the remove runs
• def remove.next.lockthe lock's step, once the remove succeeds
• def remove.next.madethe remove refused is the plan; otherwise the lock is next
• def remove.nextwhat the interpreter does next for `ez remove`: in a project of its own, what remove/relock.bend says; in a workspace, the remove, then the root's lock
• def remove.planned`ez remove`'s plan, wherever it runs

src/ws/root.bend

• type Aska directory at or above where ez runs: its path from the top of the checkout, and the path from it down to where ez runs
• type Upone such directory, read: its ez.toml's text, or None when it has none
• type Foundwhere a command run in a directory stands: in a project of its own, in a workspace at `root` as the member `rel` below it (`[]` for the root itself), or nowhere, because a workspace table above it could not be read
• def here.ofwhere ez runs, from what `git rev-parse --show-prefix` printed: the segments before the `/` it ends with, none at the top.
• def asks.underevery directory asked about from one segment further down, now one segment further from the top
• def asksthe directories whose ez.toml is read: where ez runs, then each directory above it in turn, ending at the top of the checkout
• def claimswhether a workspace root makes the directory this far below it a member: the root itself always, and any other when an entry names it and no exclusion does
• def root.claima workspace root claims the directory, so the search ends there, or does not, and goes on above it
• def root.readwhat one directory's ledger says, against what the directories above it decided
• def root.atone directory, with or without a ledger
• def root.gothe root, from the directories read, nearest first: the first whose ledger is a workspace root that claims where ez runs, a table that could not be read if one comes first, and a project of its own when there is neither

src/ws/run.bend

• type Searchedwhat the search found, and the top of the checkout it searched from
• def ledger.patha directory's ez.toml, from the top of the checkout
• def read.upsthe ez.toml of every directory the search asks about, nearest first
• def search.atthe search, once git said where ez runs.
• def here.gitwhere ez runs, from what git printed, or nothing when git could not say
• def searchthe search for the root, from where ez runs up to the top of its checkout
• def argvthe program's own name, and every word after it
• def hop.gothe same words run again at the root
• def hop.endthe hop's status, as this command's
• def hop.runa run at the root, which ends as that run ended
• def hop.ata command acted on as its hop says
• def at.searchedwhat the search found, acted on