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/lock/world.bend

• def depthe dependency ez.toml names `name`, as `M.dep` finds it
• def ledger.hubthe hub a ledger names
• def next.upa plain lock's is ez.toml as it is.
• def nextwhat the upgrade decides on a World, or nothing around a plain lock
• def next.originsthe origins the lock reads packages by
• def next.hubthe hub it names
• def laid.replya tree the upgrade checked out at a new rev, as the answer to the package question the lock would ask about it: a clone, weighed
• def laid.replies
• def replies.ofthe package answers the lock reads: the trees the upgrade checked out, then every answer the World holds
• def judged.ofevery package answer judged against the ledger the lock is made from
• def sources.swapevery committed source with each hash the upgrade moved rewritten in its imports, as the upgrade writes it
• def listing.swap
• def listing.movedthe committed sources as the lock reads them: as the upgrade leaves them, which is as they are when no hash moved, and always for a plain lock
• def listing.of
• def inputs.ofwhat a World is, as far as the lock may tell, once the upgrade decided
• def inputswhat a World is, as far as the lock may tell
• def reclone.howone answer as a fresh clone would have it: a tree read from BEND_LIB is instead cloned at the rev the ledger pins and weighed to the narHash the ledger records.
• def reclone.one
• def reclone.allevery answer as a fresh clone would have it.
• def reclonethe World a fresh clone of the same commit gathers: the same ledger, the same committed sources, and every tree it would have read from BEND_LIB cloned and weighed instead, since a clone has nothing there

src/pkg/path.bend

• type Walkwhere a normalisation has got to: `abs` is true for a path that began at the root, `out` the components kept so far, reversed
• type Compwhat one component of a path turned out to be
• def comp_ofa component classified.
• def up.roota climb with nothing left to climb off: at the root it goes nowhere, and in a relative path it is kept, since the package may still be re-rooted under it
• def up.backa climb past a component that is itself a climb keeps both
• def up.goa climb against what has been kept: it cancels the last real component
• def upa climb against what has been kept
• def up.stepa climb, with the root flag carried through
• def norm.gothe state once a component has been classified
• def norm.stepone component against the state
• def norm.rela relative path with nothing left in it is the current directory
• def norm.textthe components put back together, under the root or not
• def norm.finthe components a normalisation kept, in order
• def norm.walkthe walk one component at a time.
• def norma path with `.` and an inner `..` resolved by text.
• def base.gothe component carried so far, kept when nothing follows it.
• def base.lastthe last component of a path
• def basethe last component of a path
• def dirthe path with its last component climbed back off
• def join.atthe path before it is normalised: the second alone when there is no directory to take it relative to, the two spliced otherwise.
• def joina path taken relative to a directory.
• def tailthe last `n` components of a path
• def up.iswhether a component is a climb
• def ups.gothe climbs among components counted one at a time.
• def upshow many components of a path are climbs
• def unbenda module path without its `.bend`, which is how bend names the module
• def climbthe path with `n` of its components climbed back off, which is where a package re-roots when a module of it was reached through that many `..`
• def anchor.pathan absolute path, or a `git@` URL, as it is, or a relative path taken from `here`
• def anchor.ata URL as it is, or a path
• def anchora source as the directory `here` reads it.

src/pkg/pkg.bend

• type Itema file of a package: the path it takes inside the package, and its sha256
• type Pkga package: the files it holds, the hash that names them, and the directory their paths are written from.
• type Scanwhat a source file's header imports: modules by the path they were reached through, and the foreign C and JS bodies bend uploads alongside the sources
• type Stmtwhat one line of a source file turned out to be
• type Heada scan in progress: `head` is true while the imports still head the file
• def words.keepthe words of a line, with the runs of spaces dropped
• def wordsthe words of a line
• def blanka character bend's loader reads as white space in an import line.
• def trim.front.atthe front of a line, past one character that may be blank
• def trim.fronta line with its leading blanks dropped
• def trim.back.ata character kept before the rest of a line with its trailing blanks dropped.
• def trim.backa line with its trailing blanks dropped, read from the front, so that the trim of a line is a walk over it rather than over its reverse
• def trima line with the blanks at either end dropped, as bend's loader trims it
• type Cutthe fields of a line read so far: the field under way, and the fields after it
• def cut.puta field put before the fields after it, unless it is empty
• def cut.atone character before the fields read so far: a blank ends the field under way, and anything else extends it
• def cuta line cut at its blanks, read from the back
• def cut.alla line's fields once it is cut: the one under way before the rest
• def fieldsthe fields of an import line: what is left between its runs of blanks, as bend's loader splits it.
• def wordthe nth word, or "" when the line is shorter than that.
• def mod_of.stepthe line named a module, or it did not, with the answer already in hand.
• def mod_ofan `import <spec> as <Name>` line names a module; anything else does not
• def base_of.stepthe prelude decided.
• def base_of`import Base` brings in the prelude, which is no part of any package.
• def quieta line that neither opens nor ends the header
• def stmt_of.quieta line that says nothing about the header, decided.
• def foreign.gap.atthe rest of a line, past one character that may be skipped
• def foreign.gapa line past its `import`, with the spaces, tabs and carriage returns bend's parser skips between the word and the path dropped
• def foreign.paththe quoted path of a foreign import, once its `import` and the gap after it are gone
• def foreign.quotedwhether what follows a line's `import` is a quoted path
• def stmt_of.foreignthe foreign import decided.
• def stmt_ofa trimmed line classified.
• def scan.moda module named after the header has ended is not part of the header, so the line is ignored rather than followed
• def scan.gothe state once a line has been classified
• def scan.stepone line of a source file against the state
• def scan.finwhat a finished scan gathered, in source order
• def scan.walkthe header walked one line at a time.
• def scanwhat a source file's header imports
• def scan.modsthe modules a scan found
• def scan.foreignthe foreign bodies a scan found
• def is_huban import of a hub package, which is a dependency rather than a module of this package.
• def name.chara character a hub name holds after its first: a-z, 0-9 and -
• def name.charswhether every character is one a hub name holds
• def name.firstwhether a name opens with a letter
• def name.parta hub name: a letter, then a-z, 0-9 and -, 1 to 64 characters in all, as bend's NAMED rule reads it.
• def digitswhether every character is a digit
• def ver.numone number of a version: digits, and no leading zero unless it is `0`
• def ver.numswhether every number of a version is one
• def ver.oka version: four numbers, like 1.0.0.0
• def name.okwhether a `<name>@<version>` is one the hub rules in, as bend's `NAMED` pattern reads it