ezx
Search uses release 1.13.0.0 · 2,947 definitions
Definitions (2,947)
- def of.fuelthe same over a whole checkout
- def walk.fuelfuel enough for a walk over these files: one step for the entry and one for every import it can queue, and every import is a line of some file.
- def ofthe same, with fuel enough for every file of the checkout
- def tree.gonea path read and found missing, added to what the walk was given
- def tree.havea file read, added to what the walk was given
- def tree.addwhat a read answered, added to what the walk was given
- def resumea walk that stopped to ask, taken up again where it stopped
- def state.stopwhy a walk stopped
- def made.ioa walk's verdict as a package, with its root taken back under the checkout it was read from
- def pkg.nexta question read from disk and the walk carried on, or the walk's end judged
- def resumed.fuelfuel enough for a walk taken up again over the files read so far: a step for every file still queued, and `walk.fuel`'s step for every import those files can queue
- def askshow many files the walk from disk may ask for.
- def pkg.askthe walk over what has been read so far, and each file it asks for read and handed back, until it no longer asks
- def walk.iothe package an entry would be published as, walked over its checkout: the entry and every file the walk reaches are paths from `top`, read from disk as the walk asks for them.
- def pkg_inthe package an entry of a checkout would be published as
- def pkg.froman entry named from the working directory is walked over the working directory, and one named from the root over the whole file system
- def pkg_ofthe package an entry file would be published as: every module it reaches, every foreign body beside them, and the hash over their manifest.
- def pkg.hashthe hash that names a package
- def pkg.rootthe directory a package's file paths are written from
- def pkg.filesthe files a package holds
- def file.sumthe sha256 recorded for a file
- def nl.stepone step of a scan for a newline, with the head's answer in hand; the rest arrives as a thunk, so the first newline ends the scan
- def has.nlwhether a text holds a newline, so is more than one line
- def line.stepone step of the first line: a newline ends it, and any other character starts what the rest of the line is
- def line.firsta text's first line: everything before its first newline, the whole text when it has none
- def licwhether a file of a package is a LICENSE, which the hub passes over
- def atwhere a file stands in the hub's order
- def least.vsthe earlier of the file found so far and the next one; a tie keeps the one found first
- def least.pickthe next file weighed: a LICENSE is passed over, and any other file is the earlier of itself and the one found so far
- def leastthe first file by path among these and the one found so far, LICENSE files passed over
- def line.filea file's first line
- def line.ofthe first line of the file found, "" when there is none
- def blurbthe line the hub describes a package by: the first line of its first file by path that is not a LICENSE
- def after.stepone step of the walk below, with the head's answer in hand; the rest arrives as a thunk, so the first file that comes earlier ends the walk
- def afterwhether every file of these comes no earlier than a path, a LICENSE included.
- def name.lengthhow many characters a `0x` name is written with: the two of the prefix and the thirty-two `pkg/pkg.bend`'s `hash_of` takes off a sha256
- def is_namewhether a line is a `0x` package name and nothing else.
- def agrees.stepone line of bend's output weighed.
- def agrees.gowhether bend's output, from this line on, agrees with ez's hash, `seen` saying whether a line before it was a name
- def agreeswhether bend's output agrees with ez's hash: at least one line is a `0x` name, and every line that is one is ez's hash.
- def other.stepthe first line that is a `0x` name and not ours, "" when there is none
- def otherthe walk that finds it, one line at a time
- def dirty.stepone line of `git status --porcelain` weighed, with the rest of the walk behind a thunk so a status that names a hundred files stops at the first.
- def dirty.lineswhether any line of the status says anything.
- def blanks.stepone line of the other walk, the same way round
- def blankswhether the status named nothing.
- def dirtywhether `git status --porcelain` named a path.
- def semver.charone character of a version: a digit or a dot
- def semver.charswhether every character of a version is a digit or a dot.
- def semverwhether a version is MAJOR.MINOR.PATCH: digits and dots only, and three numbers, none with a leading zero (`K.ver.num`, the rule bend's NAMED holds each of its four numbers to)
- type Namedhow the ledger names the package on the hub: not at all, so it is published by its hash alone; by `<name>@<version>`, as bend's `--publish` takes it; or in a way ez refuses, and why
- def why.noverwhy a `publish-as` with no `version` is refused
- def why.nonamewhy a `version` with no `publish-as` is refused
- def why.namewhy a `publish-as` the hub would not take is refused
- def why.verwhy a `version` that is not MAJOR.MINOR.PATCH is refused
- def naming.bothboth keys given: the name first, then the version, then the name bend is asked for, the version with bend's fourth number, `0`, after it
- def naming.gowhich of the two keys the ledger gives.
- def naminghow `publish-as` and `version` name the package
- type Ledwhat the ledger says: the entry it names and how the package is named on the hub, by its hash or by a `<name>@<version>`, or why there is none
- def led.namedthe entry, with the name the package goes under, or why it goes under none
- def led.readthe entry a parsed ledger names, `main.bend` when it names none, and the name its `publish-as` and `version` give it
- def led.ofthe ledger read.
- def ledwhat the World's ledger says
- def entry.ofthe entry, as the walk takes it, "" when the ledger names none
- def named.ofhow the package goes on the hub; a ledger that names no entry sends nothing, so it is taken for one that goes by hash
- def namedhow a World's package goes on the hub
- def named.wordthe `<name>@<version>` the upload names the package by, "" for none
- def entrythe entry of a World
- type Statuswhat `git status` said of the project, still to ask, or why it said nothing
- def locatethe question: what git says of the directory the project is in
- def status.rana status that git answered, or the command stopped with what git said.
- def status.told
- def status.answer
- def status.of
- def statuswhat git status said of the project
- def tree.tolda file the walk asked for, added to what it is given: its text, or gone when there is none
- def tree.read
- def tree.tool
- def tree.one
- def tree.ofevery file read so far, as the walk is given them: not a whole checkout, so a file not read yet is a question
- def treethe files the walk has been given
- def fuelthe walk's fuel: one step for the entry and one per line of the files it was given, since every import it can queue is a line of one of them
- def fuel.of
- def walkedthe package the entry is published as, over the files read so far
- def hash.ofthe package's hash, "" while there is none
- def hashthe hash ez computed for the package
- def root.ofthe directory the package's paths are written from, "." for the project's
- def atthe entry's path inside the package, which is where the hub serves it: the entry's name, under the directories the package re-rooted above it when an import climbs out of the entry's directory
- def pathsthe files of a package, as paths of the project
- def tracked.stepwhether `git ls-files -v` names a path as tracked in the ordinary way.
- def tracked.has
- def stray.stepthe first path of the package that git does not track, "" when every one is tracked
- def stray.first
- type Keptwhat git said of the package's files: every one tracked, the first one it does not track, still to ask, or why it said nothing
- def kept.of
- def kept.ran
- def kept.answer
- def kept.heard
- def kept.walked
- def straywhether git tracks every file of the package.