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

• def parsea document read from TOML text: eztoml's reading of it, as sections
• def show.kva pair as `key=value`
• def show.kvsevery pair of a section, shown
• def show.secta section as `name key=value ..`
• def show.sectsevery section of a document, shown

src/tool/plan.bend

• def nonewhether a Maybe holds nothing
• def links.actwhether an act links the binary: `install` and `upgrade` do, `run` does not
• def tools.ofthe tools of a ledger that was read
• def lockedthe pins a lock's text records
• type Srca target resolved as far as the project can say: a `[tools.*]` pin, with the lock's url and rev and the file its `bin` or `entry` names; a free target, with the place its word names; or why there is none
• def over.ofthe file a pin names: its `bin`, else its `entry`, else "" so the checkout's own ledger chooses
• def pin.goa pin the lock has, or a refusal when it has none by that name
• def pin.ofthe pin the lock has for a name, or a refusal
• def pin.inthe pin the lock records under a name, one with empty fields for none
• def pinneda name the ledger pins is built as the lock pins it
• def src.picka name the ledger pins, or a free target
• def unpinnedwhether a ledger pins nothing under this name
• def src.reada project ledger that does not parse is refused
• def srcwhat the target names (EZ-TOOL-4)
• def place.pina pin names a git repository; a path is no pin
• def place.ofwhere a resolved target is
• def placewhere the target is: a remote with its cache slug, a path, or nowhere
• def over.srcthe file a pin names, "" for a free target
• def overthe file the target names for itself, "" when the checkout chooses
• type Locwhat git said of a local path, still to ask, or why there is nothing
• def loc.ofwhat git said of a path, looked up
• def locatethe question about a local path, `~` expanded
• def locwhat git said of a local path
• def loc.absthe real path of a local target, "" while it is not known
• def local.samethe commit a local path builds: HEAD, when `git status` answered and named nothing, and the path is the top of its checkout.
• def local.clean
• def local.go
• def local.rev
• def loc.revthe commit of a local target, "" while it is not known
• def head.saidwhat a remote's HEAD printed
• def head.revthe commit HEAD names, "" while it is not known
• def rev.freethe commit of a free target
• def rev.ofthe commit of a resolved target
• def revthe commit built, "" for none (EZ-TOOL-4)
• def rootthe cache root, "" for none
• def dir.ofthe cache directory of a target: `<root>/<slug>` for a remote, and `<root>/local<abs>` for a path
• def dirthe target's cache directory
• def revdira remote's checkout of a commit lives in its own directory, so a pin and a free run at other commits never clone over each other
• def stamp.atthe checkout's record, written once every file of it is laid
• def top.ofthe checkout: under the cache for a remote, the path itself for a path
• def topwhere the checkout is
• def lib.ofthe library the checkout's lock is fetched into: the checkout's own for a remote, and one under the cache for a path, which is never written into
• def text.ofa file's text as it was answered, None when it is missing or not answered
• def read.got
• def open.ofwhether a question is still open
• def openwhether a question of ours is still open
• def opens.stepa question kept when it is still open
• def opensthe questions of these still open
• def yes.ofwhether an answer said yes
• type Cothe checkout's ledger and lock, read where it is; the files of one cloned now; the questions still open; or why there is none
• def clone.askthe files a checkout at a rev is made of, asked of git
• def co.clonethe checkout git gave, still to ask, or why there is none
• def readsthe three files of a cached checkout
• def co.freshthe cached checkout is this commit and finished, or it is cloned again
• def freshwhether the cached checkout's record names this commit.
• def co.remotea remote's cached checkout, once its three files are read
• def co.locala path's ledger and lock, once they are read
• def co.ofthe checkout of a place
• def cothe checkout of the target
• def co.tomlthe checkout's ez.toml
• def co.lockthe checkout's ez.lock.toml
• def label.ofthe checkout, as a person knows it: a remote at its commit, or a path
• def labelthe checkout, as a person knows it
• def led.ofthe checkout's ledger as read.
• def ledthe checkout's ledger, read
• def plainwhether the checkout is a plain Bend repository: it has no ez.toml, so no git dependencies and no lock.
• def libwhere the checkout's lock is fetched, or, for a plain repository, where bend fetches its hub imports: a library of the target's own under the cache, beside its binaries
• def man.ofthe model of a ledger that read, an empty one otherwise
• def manthe checkout's ledger, empty when it did not read
• def man.namethe checkout's `[package] name`, `bin` and `entry`
• def man.bina ledger's `bin`
• def man.entrya ledger's `entry`
• def stema file's last component without its `.bend`: `src/cli.bend` is `cli`
• def repo.namea repository's name: the last component of its URL or path, a trailing slash and `.git` taken off, so `https://github.com/o/bolt.git` is `bolt`
• def plain.namethe link's name for a plain repository: the stem of the file built, or the repository's name when that is `main`, since every plain repository has one
• def origin.ofwhere the checkout came from, as a person named it: a remote's URL, or a path's real path
• def originwhere the checkout came from
• def binthe checkout's `bin`
• def entrythe checkout's `entry`
• def name.okwhether a package name can name the link and the binary: none at all, or a TOML bare key, so it holds no `/` and cannot be `..`
• def chosenthe file built: the pin's `bin`, then its `entry`, then the checkout's `bin`, then its `entry`, then `main.bend` (EZ-TOOL-7)
• def wishthe file asked for ahead of the checkout's own: the pin's `bin` or `entry`, else the file `--entry` names, else "" so the checkout chooses.
• def choicethe file built, relative to the checkout: `main.bend` for a plain repository unless `--entry` names another (EZ-TOOL-7)
• def filethe file built, in the checkout
• def insidea path's part under a directory, "" when it is not under it
• def present.ofwhether the file built is in the checkout: among the files git gave, or read where the checkout is.
• def presentwhether the file built is there
• def file.asks.ofthe question whether the file built is there, for a checkout read where it is; git gave every file of one cloned now
• def file.asks
• def name.ofthe name the link and the binary are given: for a plain repository the one `plain.name` gives it, and the package's for an ez project
• def name.rawthe name the link and the binary are given
• def namethe link's name: the package's, or `app` (EZ-TOOL-7)
• def keywhat the binary is made from: the commit, the file and the bend (EZ-TOOL-2)
• def stamp.ofthe directory a record's binary lives in, named by the record
• def bdirthe directory of this record's binary