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/io/file.bend

• def read.sizeda file read whole, with fuel enough for the size it reported
• def read.openedwhat an opened file holds, or nothing when it would not open
• def reada file's text, or None when it cannot be opened
• def write.okwhether a write reported success
• def write.donea write's outcome, once the handle is shut
• def write.openedthe text written to an opened file
• def writea file replaced with this text; False when it could not be written
• def text_ofa file's text, or "" when there is none

src/ledger/ignore.bend

• type Rulewhat one line of an ignore file is to ez
• type Linea line, with what it is to ez beside it
• def allowthe gitignore line that keeps one committed tree
• def leadone leading `/`, which anchors a pattern to the file's own directory and so changes nothing for a `.gitignore` at the root
• def trailone trailing `/`, which only narrows a pattern to directories, and every path ez names here is one
• def barea pattern with both of those dropped
• def loose.underan exception under `.ez/lib/` names the hash after the prefix
• def loose.negan exception: the re-included library directory, or one tree under it
• def loose.posan exclusion: the whole of `.ez`, what is inside it, or what is inside its library directory
• def loose.goa trimmed line, read by whether it is an exception
• def loosea line that is not written the way `allow` writes one
• def canon`!.ez/lib/` with nothing after it is the directory, with a trailing slash
• def kind.goa line written the way `allow` writes one names the hash after the prefix
• def kindwhat a line of an ignore file is to ez
• def tagevery line, with what it is
• def hashes.putthe hash an allowlist line names, in front of the rest
• def hashesevery hash the allowlist lines of a file name, in order.
• def others.puta line that is not ez's, in front of the rest
• def othersevery line that is not ez's, in order: the lines `sync` must not touch
• def vendors.puta dependency's hash, in front of the rest, when its tree is committed
• def vendorsthe hash of every dependency marked `vendor = true`, in the order the ledger wrote them.
• def namedwhether a list of hashes already names a hash
• def once.puta hash in front of the rest, unless it is passed over
• def once.seenthe hashes seen so far, with this one when it was kept
• def once.goeach hash once, where it first appears, passing over any `seen` already holds.
• def vendedthe hashes the allowlist must name: every dependency marked `vendor = true`, each hash once, in the order the ledger first names it.
• def allow.eachone allowlist line per hash
• def allowsthe allowlist lines of a ledger, in its order
• def samewhether two kinds are the same rule.
• def has.stepthe rest of the scan only when this line was not it
• def haswhether a file already has a line of this kind
• def rule.puta rule, in front of the rest, when the file does not have it
• def rules.gothe three rules the allowlist needs, less the ones already there
• def rulesthe rules a file lacks
• def needthe rules go in front of the block only when nothing else puts them in: a `.ez/` line is replaced by them where it stands, and a ledger that vendors nothing needs none
• def blockthe allowlist block: the missing rules, then one line per vendored hash
• def placedthe block, where it goes: at the first allowlist line, or at the end
• def walkevery line, walked once.
• def lines.gothe walk over a file's lines, each already read for what it is
• def linesthe lines of an ignore file with the allowlist the ledger's dependencies call for: exactly the vendored hashes, and nothing else changed
• def unend.gothe last piece of a file cut at its newlines, dropped when it is empty: it is what follows the newline the file ends with, and not a line a person wrote
• def unendthe lines of a file cut at its newlines, less that last empty piece
• def file.linesthe lines of a file.
• def file.textlines written out as a file, each ending with a newline, which `file.lines` reads back as those lines
• def text.outa file whose lines did not change comes back byte for byte, whatever it ended with.
• def syncthe ignore file with the allowlist the ledger calls for.

src/ledger/manifest.bend

• type Sourcewhere a package's bytes come from.
• type Depone tracked dependency
• type Toolone pinned CLI.
• type Manifestthe ledger: this package, the file `ez build` and `ez run` take, the file `ez tool run`, `install` and `upgrade` build when one is named, the hub its packages come from ("" for bend's own), the hub name and the version `ez publish` names the package by ("" for none, which publishes it by its hash alone), everything the package depends on, and every CLI it pins
• type Reada manifest, or why it could not be read
• def valuethe value written for a key in a section, or "" when it is absent
• def pairs.atthis section's pairs when its name matches, otherwise the rest's
• def pairs_ofthe pairs of the section with this name, or none
• def flag`vendor = true`, bare or quoted, is the only spelling that commits the tree
• def source.gono `git` key means the package lives on the hub
• def source.nameda hub source, with the `<name>@<version>` a dependency's section records under `hub`, "" for none.
• def root.ora git section that names no root was written from the top of its checkout, which is the root a lock already spells out as "." and the only one a ledger written before this key existed can have meant
• def source.wsa dependency section's source, once it is known whether it names a workspace member, which only a dependency can be
• def source_ofwhere a dependency's section says its bytes come from
• def dep_ofa `[deps.<name>]` section as a dependency.
• def dep.namea dependency's own name, for finding or replacing it
• def dep.hasha dependency's hash, which is the `0x` name its import line carries
• def dep.entrythe file inside the package a dependency was added by, which is the file its hash was computed from
• def deps.puta section joins the dependencies only when it is a `[deps.<name>]`
• def name_ofa section's name, for deciding what it is
• def depsevery `[deps.<name>]` section, as dependencies, in the order written
• def tool_ofa `[tools.<name>]` section as a pinned CLI.
• def tool.namea tool's own name
• def tool.entrythe file a pin names as its entry, or "" when the tool's ledger names it
• def tool.binthe file a pin names as its binary, or "" when the tool's ledger names it
• def tool.sourcewhere a pinned CLI's bytes come from
• def tools.puta section joins the tools only when it is a `[tools.<name>]`
• def toolsevery `[tools.<name>]` section, as pinned CLIs, in the order written
• def missing.ata dependency with no hash cannot be resolved, so it is reported by name
• def missing.isa `[deps.<name>]` section is missing its hash when the key is absent
• def missingthe first dependency section with no hash, or "" when every one has one
• def problemthe first problem with the document, or "" when there is none.
• def buildthe ledger, once the document is known to be sound
• def read.gothe ledger, or the problem that stopped it
• def readthe sections judged, then read
• def parse.gothe parsed document, taken apart
• def parsethe ledger written in an ez.toml
• def show.sourcehow a dependency reads on one line
• def show.dep`<name>=<hash>@<hub|git>`
• def show.depsevery dependency shown, in the order written.
• def show.mthe ledger on one line, for a test or a report
• def showthe ledger, or the error, on one line
• def find.pickthis dependency when its name matches, otherwise whatever the rest gave
• def find.atthe dependency of this name, or a blank one
• def findthe dependency of this name, or one with empty fields
• def depthe named dependency of a ledger that was read