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/sha/nar.bend

• def regulara regular file's node, marked executable when it is
• def symlinka symlink's node
• def entryone directory entry: its name and its node
• def entriesa directory's entries, in the order given
• def directorya directory's node, its entries in the order given
• def dira directory's node as NAR writes it: its entries sorted by name, whatever order they were listed in.
• def archivea whole NAR: the magic, then the root node
• def b64.digit.plus
• def b64.digit.lt62
• def b64.digit.lt52
• def b64.digit.lt26
• def b64.digit
• def b64.triple
• def b64.one
• def b64.two
• def b64standard base64, padded with `=`
• def hex.val.upper
• def hex.val.lower
• def hex.val.digit
• def hex.val
• def hex.bytes
• def sri.hex
• def srithe SRI of some bytes: `sha256-` and the base64 of their digest
• def emptythe node of an empty directory
• def nulthe NUL that ends every field of the listing
• def pusha char put in front of the first field, which a text that does not end with a NUL leaves open
• def cut.atone char of the listing read: a NUL ends a field, any other char is the next of the field it is in
• def cutthe fields of a listing, each ended by a NUL, exactly as they were printed
• def cleanwhether a text holds no NUL, as no name and no link target can
• def joinedfields as the listing prints them, each ended by a NUL
• def clean.allwhether every field holds no NUL
• def owner.execwhether a file's owner may execute it, from the mode `find` prints as `%M`, `-rwxr-xr-x`: the fourth character is `x`, or `s` when the setuid bit is set as well.
• type Rowone path of the listing: its type as `%y` gives it (`d`, `f`, `l`), its mode (`%M`), its name (`%f`), its path from the top (`%P`) and a symlink's target (`%l`)
• def rowsthe listing's fields, five to a path.
• def listing.argvwhat `find` is asked to print of every path under `top`, the top first, each field ended by a NUL.
• type Entone path of the tree with what the NAR holds of it: a file's text, or a symlink's target, as `body`
• type Framea directory still open: its path from the top, its name, and the entries found in it so far
• type Statewhere the build stands: the paths still to place, the directory they are being placed in, and the directories around it
• type Movea step of the build: another state, or the finished node of the top
• def leaf.of
• def leafa file's or a symlink's node
• def underthe path of an entry named `name` inside the directory at `at`
• def closethe directory on top finished: its node is an entry of the one around it, or the whole tree when there is none
• def ent.kindan entry's type, name and path, and an open directory's path
• def ent.namean entry's name
• def ent.atan entry's path from the top
• def frame.atan open directory's path from the top
• def placea path inside the directory on top: a directory is opened, anything else is an entry of it, with its leaf's node
• def step.entthe next path: placed when it is inside the directory on top, which closes otherwise
• def stepone step of the build
• def build.gothe build, under fuel
• def buildthe node of a directory, from its paths in the order `find` lists them.
• def tree.topthe node of the whole tree, from its listing with the top first: a directory is built, a file or a symlink is a leaf
• def treethe node of the whole tree, or none for an empty listing

src/share/args.bend

• def nonemptythe non-empty strings
• def text_ofa variable's text; unset, ""
• def copythe arguments the process was started with.
• def splitthe first argument and the ones after it.
• def atthe nth argument, or "" when it was not given.
• def restevery word after the first, which is what `run` forwards to the entry
• def allevery argument after the program's own name, each one readable twice
• def run.linethe command `ez run` starts: bend on the entry, with every word after `run` (EZ-TOOL-9)
• def drop`n` words dropped.
• def undasha leading `--` is the separator, not a word the program was given
• def tool.leadthe words after `tool run` with a leading `--entry <file>` taken off.
• def tool.restthe words `ez tool run` forwards: everything after the target, with one leading `--` taken off
• def tool.line`tool run` with its target, and without the words the program is given.
• def tool.flagged`tool run` with its `--entry <file>` and target, when it has the flag
• def tool.parsethe words of `tool run` the parse reads: the flag when it leads, and the target
• def is.tool.runwhether this line is `tool run`
• def argv.tool`tool run` parsed as the command and its target; any other line as itself
• def argv.run`run` parsed as the command alone, so the words it forwards are not flags
• def argv.ofa `run` line and a `tool run` line are parsed without the words they forward.

src/share/cap.bend

• def gbhow many gigabytes one `bend` may have.
• def okwhether a `bend` can be capped.
• def scopethe cgroup a capped run gets.
• def prethe words a capped run is prefixed with, or none when nothing can cap it
• def argva program's arguments dressed the way the cap wants them, for a caller that is not going to run it here.
• def runa program run under the cap, with this project's BEND_LIB set for it
• def killedthe status the kernel leaves on a process it killed for memory
• def whywhat to say when a run died for memory rather than for being wrong
• def warningwhat is said when nothing is capping the jobs
• def warna warning printed once when nothing is capping the jobs
• def warn.errthe same warning on stderr, for a command whose stdout is the program's

src/share/env.bend

• def or_elsea value, or the fallback when the variable was unset or empty
• def varwhat a variable holds, with a default for when it holds nothing
• def libwhere this project's packages live
• def linethe command with the project's BEND_LIB in front of it
• def dirs.buildthe directory `ez build` writes into: `bin` when it was not told where
• def dirsthe directories bend writes into for a command and does not make itself: `.ez` for `ez check`'s JS, and `bin` for `ez build`'s default output.

src/share/exec.bend

• def execa program run with this project's BEND_LIB set for it
• def makethose directories made.

src/share/pass.bend

• def ezpass.runthe program and its arguments, newline separated, run with no shell between and nothing captured.
• def runa program run with its arguments, on ez's own stdio

src/share/pin.bend

• def gap.gitwhy a plain lock cannot copy a git pin as it stands, or "" when it can.
• def gapwhy a plain lock cannot copy a pin as it stands, or "" when it can.
• def gaps.stepthis pin's gap when it has one, otherwise the rest's.
• def gapsthe first pin, in ledger order, a plain lock cannot copy, or "" when it can copy every one

src/share/say.bend

• type Spina spinner that is running, or none.
• def brief.gothe first twelve characters of a commit, which is enough to tell one from the next.