bend-lint-rules

Search uses release 0.2.0.0 · 801 definitions

Releases (5)

Definitions (801)

layout/format.bend

def Split.apply
def Split.visit
def should_drop
def drop_partsDrops the trailing parts that hold only newlines, keeping one part.
def content.sep
def content.go
def contentThe parts' docs with their separators, last first.
def opening
def closingA generic's closing > stays glued to the term before it: Bend parses a spaced > as a comparison, even across a newline.
def Split.doc
def mode_ofBuild -----
def start
def visit
def finish
def buildThe doc of a list of trees, read as mode says.
def sequence
def pushPrinter ------- Jobs for a Cat's docs, last first, so its first doc ends on top.
def fits.flat.of
def fits.flatA doc printed flat, whole: past the width, or up to a break within it.
def fits.width
def fits.step
def fits.go
def fits.from
def fitsWhether the jobs fit before their first break, from col.
def col_of
def print.strText goes out after the pending whitespace; its own trailing whitespace becomes pending.
def print.line
def print.is_flat
def is_unbounded
def print.step
def print.goThe text so far; pending whitespace is never written at the end.
def printThe doc at indent; fuel bounds the steps of the printer and of each fit.
def joins.ofRecords -------
def joinsWhether a newline between previous and rest continues the record.
def records.newline
def records.step
def records
def cut.step
def cut.go
def cut.is_inlineWhether the cut has a body after its colon that is not a comment.
def is_not_hash
def split_hash.of
def split_hash
def import_space.of
def import_space
def is_alias_at.as
def is_alias_at
def alias.go
def alias
def import_doc.of
def record_endWhere the record that head starts ends.
def import_docPaths and aliases have their own grammar: / and - are not operators there, so an import keeps its text and only its spacing changes.
def decl_doc.of
def decl_doc.cut
def decl_docA declaration's body on the line of its colon moves to the next line, indented.
def record_doc
def joinedThe text of the first tokens of `xs`, after `acc`, the texts so far, last first.
def is_unsafe
def gapped
def rows.line
def rows.step
def rows.go
def is_head_empty
def drop_empty
def join
def text_of.trimmedThe rows, last first, joined, without the empty rows at the end, with a newline.
def text_of
def format.text
def format.of
def formatThe formatted text, or None{} if its delimiters do not balance.
def differWhere `a` and `b` first differ: `same` is whether the characters before `at` were the same.
def line_endWhere the line that `s` starts, at `i`, ends: before its newline, or at the end of the text.
def judged
def judge
def first_newline
def newline.preserve
def newline.crlf
def newline_of
def width_of
def settings
def run
def options
def rule

layout/imports.bend

type EntryOne import: where its alias is, whether it is Base, its written path, its alias, the file it loads, and its text (the comment lines above it, then its line).
type DedupedThe imports read so far, each file's first only: the files they load, each with its alias; the imports kept (last first); and the operations that point a dropped import's uses at the kept one's alias.
type BlockThe block, as written: where it starts and ends, and its imports, last first.
def is_blankText ====
def kept
def commentsThe comment lines of `s`, a run of whole lines, each with its newline; blank lines dropped.
def ended
def add.lineThe import on the line from `beg` to `end`, after the block so far.
def addThe import whose alias is at `at`, after the block so far.
def blockThe block of the imports among `nodes`.
def loads_ofDuplicates and order ====================
def dedupe.keptAn import read, after those before it: kept, if its file has no import yet; else dropped, with its uses pointed at `first`, the alias of the file's first import.
def dedupe.add
def dedupeThe imports of `es`, in order, after those of `d`, each file's first only.
def is_beforeWhether `a` may come before `b`: Base first, then by path, then by alias.
def textsThe texts of `es`, after `acc`, the texts so far, last first.
def verdictRule ====