cli

Releases (2)

• 0.2.0.0 indexed
• 0.1.0.0 unindexed

Definitions (1,008)

cli.bend

• def roff_positionalA positional in italics, apart from its repeat.
• def roff_entry
• def roff_positional_entry
• def roff_positionals
• def roff_option_entry
• def roff_optionsThe visible options under a heading, "" for OPTIONS.
• def roff_builtins
• def roff_headings
• def roff_command
• def roff_commands
• def roff_arg
• def roff_env_names
• def roff_env_orderHow a variable after the first is read, if there is one.
• def roff_env
• def roff_envs
• def roff_examples
• def sub_pages
• def init_words
• def parent_pagesThe parent's page, none at the root.
• def roff_refs
• def roff_see
• def roff_synopsis
• def roff_section
• def roff_view
• def find_version
• def roffThe man page of the command at the longest valid prefix of path (§11).
• def scriptThe completion script for shell s (§11).
• type Outcome
• def sub_atThe subcommand at path, from found on.
• def builtin_name
• def field_values
• def shell_namedThe shell completions was given, which one_of limits to these three.
• def builtin_page
• def outcome_acceptedV6: the completions built-in prints its script and man its page, plain; any other path is left to decode.
• def outcome_parse
• def outcome_lint
• def outcomeeval through V6: a lint failure, help, version, the V3 summary, an error or a built-in's output is Shown; Matched is a parse left to decode.
• type LintedA Cmd that passed lint, from linted: eval_linted skips the lint eval runs.
• def linted_found
• def lintedLint c once: a Linted, or lint's problems in the order problems lists.
• def outcome_lintedoutcome on a Linted's spec, without the lint.
• type Step
• def usage_errE12: a decoder's Usage message as an error at the matched scope, printed as given, in stderr's colors.
• def faulted
• def decodedV7: Done is Go with term's decisions; a fault exits 70 or 2.
• def eval_step
• def eval_witheval with the decoder as a value, so a law can quantify over decoders.
• def evalThe whole CLI as a function.
• def eval_linted_witheval_linted with the decoder as a value.
• def eval_lintedeval on a Linted, without linting its spec again.
• def env_namesEach arg's env name in pre-order: an arg's own, then its subcommands'.
• def distinctkept, then each name not yet in it.
• def vars
• def columns_okCOLUMNS sets the width when as_nat reads it and it is at least 1.
• def columns_valid
• def columns_width
• def tty_columnsstdout's columns if it is a TTY, else stderr's if it is one, else 0.
• def nonzerofirst, unless it is 0.
• def width_or
• def probe§7.3: the host from Run.host's readings; the width is COLUMNS, else the TTY columns, else 80.
• def act_code
• def act_exit§7.2: act's code, or 70 with a stderr line when it exceeds 255.
• type RanWhat a run prints and how it ends: its exit status, its stdout text and its stderr text.
• def owed_end
• def owed_after
• def owed"\n" unless s is empty or ends with one: what IO.print_err adds to s.
• def ran_exit
• def ran_actr with act_exit's mapping: a code above 255 becomes 70, with the bug line after r's stderr.
• def ran_step
• def invoke§7.2: what Run.planned writes and exits with, given the host and argv: Quit's code and text, or plan's run on the value and terminal, mapped by ran_act.
• type Utf8LeadWhat a byte starts: no UTF-8 sequence (a continuation byte, C0, C1, F5 to FF, or a value past 255), or one with more continuation bytes, the code point bits the byte carries, and the least code point a sequence that long may hold, below which it is overlong.
• def utf8_lead
• def utf8_next
• def utf8_tailThe code point acc continues to through the first more bytes of rest, each a continuation byte (80..BF); None if rest ends first or one is not.
• def utf8_scalarA decoded code point, if it is a Unicode scalar at least least.
• def byte_escapeU+DC00 plus byte b, PEP 383's escape for a byte that starts no well-formed UTF-8 sequence; U+FFFD for a value past 255, no byte.
• type ArgCharA char decoded from argument bytes, and how many bytes after its first it took.
• def arg_found
• def arg_seq
• def arg_char_by
• def arg_charThe char that byte b and the bytes after it, rest, start.
• def arg_text_gostep's char, then bytes as text once step's other bytes are skipped.
• def arg_textA raw argument as text: each well-formed UTF-8 sequence as its char, and each byte that starts none as U+DC00 plus the byte (PEP 383), decoding on from the next byte.
• def cont_byte
• def utf8_bytesScalar x's UTF-8, for x from 80: 2 bytes below 800, 3 below 10000, else 4.
• def code_bytes
• def char_bytesThe bytes c stands for: an escape's byte for U+DC80..U+DCFF, a Unicode scalar's UTF-8, and U+FFFD's for any other surrogate or a value past U+10FFFF, as Bend's writer prints them.
• def arg_bytesThe raw argument arg_text decoded to s: open a file by it with File.open_bytes.

run.bend

• def Sys.isatty1 if fd is a terminal, else 0.
• def Sys.columnsfd's terminal width in columns, or 0 if it has none.
• def exit_when
• def exit0 returns, so work started with IO.fork can finish; any other code flushes stdout and ends the process at once.
• def chomp_end
• def chomp_fromc then t, less one final "\n".
• def chomps less one final "\n": IO.print_err adds it back.
• def write_out
• def write_err
• def finish§7.2 step 4: out to stdout and err to stderr, each if not empty, then exit.
• def var_found
• def read_varsEach set variable among names, in order.