bolt

Search uses release 1.26.0.0 · 1,608 definitions

Releases (12)

1.26.0.0 indexed
1.25.0.0 unindexed
1.24.0.0 unindexed
1.23.0.0 unindexed
1.22.0.0 unindexed
1.21.0.0 unindexed
1.20.0.0 unindexed
1.19.0.0 unindexed
1.18.0.0 unindexed
1.17.0.0 unindexed
1.12.0.0 invalid
expected a fresh constructor name (duplicate declaration: Ready)

at src/lsp/frame.bend:295
10 files do not load
1.11.0.0 invalid
expected a fresh constructor name (duplicate declaration: Ready)

at src/lsp/frame.bend:295
10 files do not load

Definitions (1,608)

src/lint.bend

def answer.allevery question, answered, in order
def morethe World with more answers in it
def print_alleach line printed
def execa plan, carried out: its lines printed, then its exit status
def loop.stepthe planner's questions answered and the loop gone round again, or, when there are none, its plan carried out
def loopthe loop, under fuel: the walk's bound, plus a round for the texts and one to plan.
def run.fromthe lint from a working directory; none that can be named is fatal, as no relative path could be resolved against it
def runthe linter, over the files given, or the tree below

src/lint/plan.bend

type Planwhat `bolt` prints, in order, and the status it exits with
def lines.ofthe lines a plan prints
def exit.ofthe status a plan exits with
def walk.skippeda directory the walk never descends into
def walk.barean entry's name without the "/" that marks it a directory
def walk.undera name directly under a directory, as a path
def walk.dirsthe sub-directories of a listing worth descending into, as paths
def walk.bendsthe `.bend` files of a listing, as paths (a directory's name ends in "/")
type Walka walk once it stops: the `.bend` files it found, and every directory it read, the last one read first
def walk.foundthe files a walk found
def walk.readthe directories a walk read, in the order it read them
def walkevery `.bend` file under the directories still queued, the fuel bounding how many directories are read, each read through the World's listing.
def limithow many directories the walk reads at most; past it the walk stops, silently.
def treethe walk of the tree under `.`, reading at most `limit()` directories
def files.namedthe files named, or every `.bend` file the walk finds when none were
def filesthe files the lint runs over
def is_configa bolt.bend is configuration, not source
def sourcesthe paths that are source
def inputsthe source files of the run, in file-list order
def absa path as the one file it names wherever it is spelled from: resolved against the working directory when relative, then normalized (src/rules/imports.bend), so `a.bend`, `./a.bend` and `/w/a.bend` run from `/w` are one
def normseach path resolved (abs)
def unseenthe paths that resolve to none of the paths seen
def graphthe files a run reads its roles from: every source the walk of the tree finds, then each source of the run the walk does not find (one named outside the working directory), so each file is read once.
def seen.haswhether a path is among the paths
def uniqeach path once, where it first appears
def roots.ofthe directories the walk read that hold a main.bend, `.` left out
def roots.namedthe package roots but `.`, as the walk names them (`./w3c`)
def rootsthe package roots but `.`
def packageseach package root as the project rules take it: its directory as a digest names one (`w3c/`)
def dirs.ofthe directory of each path
def conf.dirsthe directory of every source, each once: every finding's path is a source's, so these are the directories grading needs
def conf.chainthe bolt.bend candidates of a directory as a path names it, nearest first: the directory resolved against the working directory, then each parent up to the root
def conf.candsthe bolt.bend candidates of each directory, nearest first
def asks.entriesthe listing of each directory, as a question
def asks.textsthe text of each path, as a question
def liststhe listings the plan reads: every directory the walk of the tree reads, whether files were named or not, since a named file's role is read from the imports of the whole tree (graph)
def textsthe texts the plan reads: each source, every file of the graph, and every bolt.bend candidate of the sources' directories, each once
def looksevery question the plan reads the World through: the listings, then the texts
def unansweredthe questions a World does not answer yet
def wants.pickthe listings still open, or, once there are none, the texts still open
def wantsthe questions a World still leaves open.
type Gota source path and the text the World holds for it
def gotseach source with what the World answers for it
def unreadone finding for each source that could not be read
def srcs_ofevery source that was read, parsed once for every rule
def per_file.roleevery source's findings from the per-file rules, each told its role among the marks (src/role.bend)
def facts.ofthe facts (src/role.bend) of each file the World read, from its text, each at its path resolved against the working directory (abs)
def marks.keyeach path's mark as the path is spelled: its role among marks taken over resolved paths (abs), neither when it has none there
def marks.namedthe marks of a run over files named on the line: every file of the graph read for its imports, the walk taken over their resolved paths, and each named file's role looked up there as it is named
def marks.runthe marks a run's roles are read from: over the whole tree, the sources' own; over files named on the line, the graph's, every file of the tree read for its imports, so the main.bend that imports a named file makes it code even when it is not named
def conf.firstthe path of the first candidate the World holds a text for, as a list of one; none when it holds none
def conf.usedthe bolt.bend that grades each directory, in directory order: the first of its candidates the World read, as conf.near reads it; none for a directory graded by the defaults
def gradersevery bolt.bend grading reads, each once, in the order its directories come
def settings.atthe `setting` rule's findings on each bolt.bend the World read, in order
def settingsthe `setting` rule's findings: each unknown setting of every bolt.bend grading reads (src/rules/correctness/setting.bend)
def found.atevery finding of every rule, ungraded, from the sources and what the World answers for them: the read failures, the per-file findings of each source, then `setting`'s over each bolt.bend grading reads, then the project rules' over every source and the other packages
def foundevery finding of every rule, ungraded
type Confa directory and the config its findings are graded by
def texts.atwhat the World holds at each path
def conf.neara directory's config: the nearest bolt.bend the World could read among its candidates, or the defaults
def confs.ateach directory's config
def confsthe config of every directory grading needs
def conf.findthe config of a directory, from the table; one the table does not hold is worked out the same way (every finding's directory is in the table, so this never happens in a run)
def config.atthe config a finding at a path is graded by: its directory's
def gradeevery finding graded by the config of its directory, in order, the ones at off dropped
def noqathe `noqa` rule's findings on each file's marks, against the graded findings, each put at its file as a per-file rule's are
def afterthe graded findings no mark silences, in order, then the `noqa` rule's, graded by the grader given: nothing silences what `noqa` reports
def finalevery finding of the run, graded, then silenced by the marks of the sources, then `noqa`'s own, which judges a project rule's code only when the run is the whole tree.
def errors.atone more at error, or the count as it was
def errorshow many are errors
def warnings.atone more below error, or the count as it was
def warningshow many are not errors
def has_errorwhether any is an error
def count`1 error`, `2 errors`
def summary`clean`, or the counts
def show_allevery graded finding as a line
def plan`bolt` over a World: every graded finding no mark silences as a line, then `noqa`'s, then the summary of those, and exit 1 exactly when one is an error

src/lint/world.bend

type Aska question the planner asks.
type Answerthe answer to one question.
type Replyone question, answered
type Worldeverything `bolt` reads: the paths named on the command line, the working directory (absolute) that relative paths are named from, and every answer the interpreter gave, in the order it gave them
def paths.ofthe paths named on the command line
def cwd.ofthe working directory the run was started in
def ask.eqwhether two questions are the same question
def answer.inthe first answer given to a question
def answerthe answer a World holds for a question, None while there is none
def answeredwhether a World answers a question
def listing.answera listing's names; anything else lists nothing
def listing.got
def listinga directory's entries, a sub-directory's name ending in "/"; none while the directory is not listed yet
def text.answera read's text; anything else is no text
def text.got