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/ez/start.bend

def namedthe name a ledger that parsed gives the package
def build.namedwhere a build lands when nothing said: `bin/<package name>.out`.
def build.outwhere a build lands: what was asked for, or the default
def linethe line each command starts bend with, over a ledger that parsed: the entry checked into `.ez/check.js` and never run, built to a native binary, or run with every word after `run` (EZ-TOOL-9)
def readwhat a command does with the ledger it read
def startwhat a command does with ez.toml's text, None when there is none
def codethe status `ez run` exits with, given the status of the program it started (EZ-OUT-1): 1 for a refusal, which started none, and the program's own status otherwise, as `cargo run` exits.
def whywhy a command refused, or "" when it started bend

src/ez/target.bend

type Placewhere a target names, or why it names nothing
def plain.ata char a GitHub owner or repository may hold besides a dot: a letter, a digit, `-` or `_`
type Markwhat one char of a target is, as far as telling a shorthand from a path goes.
def kind.word
def kind.tilde
def kind.dot
def kind.slash
def kind.colon
def kinda char's kind
def name.keepone char of a name, with the rest of the name still to be asked about.
def name.allevery char a letter, a digit, `-`, `_` or `.`
def seg.dotsafter `..`: one more name char, so the segment is not `..`
def seg.dot2the second char after a leading dot
def seg.dotafter a leading `.`: more, so the segment is not `.`
def seg.firstthe first char of a segment
def segone segment of a GitHub shorthand: letters, digits, `-`, `_` and `.`, at least one of them, and not `.` or `..`, which name a directory
type Halvesa word cut at its first slash, or not cut because a char before any slash could not be in a shorthand
def halve.puta char put back in front of the left half
def halve.atone char of the first segment.
def halvethe word before its first slash and the word after it
def bend.filea word naming a Bend file.
def repo.segthe second segment of a shorthand: a segment that is not a Bend file
def github.halvesboth segments of a shorthand, where there are two
def github.ok`owner/repo`: exactly two segments, each a `seg`, the second not ending in `.bend`.
def climb.stepone step of a scan looking for `..`.
def climbwhether any component is a climb
def slug.oka slug that stays under the cache: non-empty, relative, and with no `..`
def remotea remote whose slug can be a directory, or a refusal when it cannot
def cut.end`s` with a suffix of `n` chars taken off when it ends in that suffix.
def unslasha trailing slash is not part of the cache directory
def ungita trailing `.git` is not part of the cache directory
def bodyeverything after the first colon.
def drop.slashesthe `//` a scheme leaves in front of the host
def hostlessa URL with no host, `file:///srv/repo`, is on this host, and is cached where `file://localhost/srv/repo` is, rather than at an absolute slug
def slug.url`scheme://host/path` as a cache directory
def slug.scp`git@host:path` as a cache directory.
def looks.slash.atthe char after `~` or `..`: a slash
def looks.slash
def looks.dot.atthe char after a leading dot: `./` or `../`
def looks.dot
def looks.firstthe first char: `/`, or the start of `./`, `../` or `~/`
def looks.patha word that already says it is a path: it starts `/`, `./`, `../` or `~/`
def classify.scp`git@host:path`, or a path
def classify.hub`owner/repo`.
def classify.patha path prefix, or a possible shorthand
def classify.urla URL, or not
def classify.emptynothing was asked for
def classifywhat a target word names.
type Aimwhat `ez add` was asked for: a hub package by its `<name>@<version>`, or a place as `classify` reads it
def aim.locala word `classify` reads as a path names a hub package when bend's NAMED rule rules it in (`K.name.ok`); otherwise it is that path
def aim.placethe place read, with only a path asked whether it is a name.
def aimwhat an `ez add` target names.
def aim.namedwhether a target names a hub package
def expand`~` and `~/…` expanded.
def entry.orthe entry, or `main.bend` when a ledger names none
def file.ofthe file that is built: `bin` when the ledger names one, otherwise the entry
def out.namethe binary's name: the package's, or `app` when the ledger names none
def showa place on one line, for a proof to read

src/ez/test.bend

type Tallyhow many comparisons were made, and how many of them held
def saya comparison that held says nothing.
def tally.goone more comparison, and one more pass when it held
def tallythe tally with this comparison's verdict in it
def checkwhat was wanted against what happened, reported and counted
def oneone test against its own trailer
def shortevery test the answers ran out before.
def reportevery test, in the tree's order however the run happened to interleave
def findevery test file
def done.gothe count, and the exit status it implies.
def donewhat a whole run amounts to
def out.atwhere the jobs of a run write what they print
def budgetthe budget checked the way every other thing here is checked.
def run`ez test`: every test in the tree, all of them at once.

src/ez/timer.bend

def secondshow many seconds a whole run may take.
def bythe second the run must be finished by, worked out once at the start so that nothing later has to add anything up
def start.gothe deadline, or "" when there is none
def startthe deadline, or "" when there is none
def over.nowwhether the deadline has gone by
def over.gowhether the run has outstayed its budget, which a run with no budget never has
def overwhether the run has outstayed its budget, which a run with no budget never has

src/fetch/plan.bend

def fetch.askthe question that fetches a package from where the lock says it comes from: a checkout of a git package at its rev, from its source as git is to read it, a relative path taken from the project; or a hub package from the hub
type Treea package's files as they arrived, with the directory the lock's paths are written from inside them, or why nothing arrived
def zipthe files a manifest names, each with the text read for it
def tree.reada manifest and the texts of the files it names, as a tree: what is under BEND_LIB, or what the hub served
def tree.saida checkout at the pinned rev, whose paths are the lock's from `root`
def tree.ofwhat arrived for a question
def text.ora text looked up, "" when it is not there
def keywhere a path of the lock is in a tree: under its root inside a checkout, and as it is in a tree a manifest names
def candevery file the lock names, with the text the tree has at its path.
def weigha file laid, weighed by its own text
def weighsevery file laid, weighed by its own text
def fitwhether one file is the one the lock names: the same path, and a text whose digest is the sum the lock records
def fitswhether every file is the one the lock names, in the lock's order.