shake

Releases (4)

• 0.7.0.0 indexed
• 0.6.0.0 unindexed
• 0.5.0.0 unindexed
• 0.4.0.0 unindexed

Definitions (339)

src/cli.bend

• def help.pads padded on the right to width n
• def text.ofa Maybe string's text, or the default
• def looks_flagwhether a string is a flag token (`-` alone is not)
• def from.rev.goa buffer of chars consed on the front (the last read first), folded onto acc
• def from.revchars reversed into a string
• def cut_eq.pick`name` and an optional `=value`, once the next char is known
• def cut_eq.chrone char of a `name=value` cut
• def cut_eq.go`name` and an optional `=value` from the body after `--`
• def cut_eq`name` and an optional `=value`
• def short_of.valthe value glued after a short letter: what follows one `=` when the rest starts with it (possibly empty, as `--name=` is), else the rest when there is any
• def by_long.hitwhether this Arg's long spelling is `name`
• def by_long.atthis Arg when the long spelling matches, else the rest
• def by_longthe Arg with this long spelling, if any
• def by_short.hitwhether this Arg's short spelling is `name`
• def by_short.atthis Arg when the short spelling matches, else the rest
• def by_shortthe Arg with this short spelling, if any
• def by_name.hitwhether this Arg's name is `name`
• def by_name.atthis Arg when the binding name matches, else the rest
• def by_namethe Arg with this binding name, if any
• def find_sub.atthis Sub when its name matches, else the rest
• def find_subthe Sub with this name, if any
• def pos.is.kindwhether this Arg is a positional
• def rest.is.kindwhether this ArgKind is rest
• def pos.iswhether this Arg is a positional
• def rest.iswhether this Arg is a rest positional
• def pos_of.putthis Arg kept when it is a positional
• def pos_ofthe positionals of a spec, in order
• def allowed.ok.atwhether `v` is among the choices; an empty list accepts any value
• def allowed.okwhether `v` is listed; the empty list answers no
• def allowedempty choices accept any value; otherwise `v` must be listed
• def bound.hitwhether this bind's name is `name`
• def bound.atTrue when the head matches, else the rest
• def boundwhether `name` is already bound
• def get_all.bind.hitthis bind's value when the name matches, else the rest
• def get_all.bind.atthis bind's value when the name matches, else the rest
• def get_all.bindevery value bound to `name`
• def ownthe bindings this command made, in binding order
• def get_allevery value this command bound to `name`
• def get.lastthe last of a list of values, or `dflt` when it is empty
• def getthe value bound to `name` last, or None when nothing bound it
• def on.ofwhether a value is `true`
• def onwhether a flag named `name` was set
• def path_ofthe names of the subcommands selected below this command, in order
• def sub_namethe name of the subcommand selected under this command
• def sub_of.picka subcommand's Matched when it is the one asked for
• def sub_ofthe Matched of subcommand `name`, when it is the one selected
• def at.stepone name further down, when there is still a Matched to go down from
• def at.gothe rest of a path, followed from where the walk down stands
• def atthe Matched of the command `path` names below this one, name by name, or None where a name is not the subcommand selected
• def parse.startthe starting walker for a Cli
• def parse.deada failed walker that keeps the rest of the state
• def parse.puta successful bind of `name` to `val`
• def parse.choicesthe choices of a found Arg, or none
• def parse.take_choicebind `name` to `val` when the value is allowed
• def parse.take_opt_valbind an option that already has its value, checked against the choices of the current command's argument of that name: a parent's argument of the same name has its own
• def parse.take_flaga flag with no glued value is set; a glued value is unexpected
• def parse.take_optan option: glued value now, or the next token
• def parse.oncea flag or single-valued option given again is refused, whatever the walk would have done with it; the walker keeps the rest of its state
• def parse.take_arg.kinddispatch on the found Arg's kind
• def parse.take_arga found Arg, or an unknown flag
• def long_helpwhether an unknown long option is a request for help: a bare `--help`, with no `=` value, before any positional of the current command is bound
• def parse.take_long.helpan unknown long option: a request for help (`--help`, as `help`), or an unknown flag
• def parse.take_long.founda long option the current command spells, or an unknown one
• def parse.take_long.nameda long option with a name, or `--=...`
• def parse.take_long.cuta long option after the `=` cut
• def parse.take_longa long option body after `--`
• def cluster.val.flaga flag's value in a cluster: the rest when it starts with `=` (which `take_arg` refuses), else none, so the next letter goes on
• def cluster.val.kindthe value a letter of this kind gives its argument: an option takes the rest of the word, after one `=`
• def cluster.valthe value the letter's argument gets, or none when no argument has it
• def cluster.ends.kindwhether a letter of this kind ends the cluster: every kind but a flag that is not followed by `=`
• def cluster.endswhether the letters after this one are no longer read as letters: an unknown letter, an option (they are its value) or a flag given `=`
• def cluster.apply.modeone letter against a walker an earlier letter failed changes nothing; otherwise it goes through `take_arg`
• def cluster.applyone letter against the walker
• def cluster.letterone letter of a cluster, unless an earlier one ended it
• def cluster.donewhether the cluster has ended after this letter
• def clusterevery letter of a short cluster `-abc`, in order: a flag binds and the next letter goes on; an option takes the rest of the word, after one `=`, or the next word when nothing is left; an unknown letter, or a flag given `=`, refuses the whole word
• def short_helpwhether a short option word is a request for help: `-h` alone, before any positional of the current command is bound, when the command spells neither `-h` nor `--help`
• def parse.take_short.goa request for help (`-h`, as `help`), or a cluster of short options
• def parse.take_shorta short option body after `-`
• def parse.take_pos.keepa rest positional stays; a plain one is consumed
• def parse.take_posthe next remaining positional, or an unexpected word
• def parse.enterthis Sub's arguments become current, with no bindings of its own; the command it leaves keeps its arguments and bindings above it
• def parse.req.gorequired and no default → Some{name}
• def parse.reqa required Arg without a default, as a missing name
• def parse.first_req.atthis missing name, else the rest
• def parse.first_req.skipa rest stays in the list, so it does not block a subcommand
• def parse.first_reqthe first leftover required positional
• def parse.enter_ora leftover required positional blocks entering a subcommand
• def parse.word.goa found subcommand, or a positional
• def parse.worda word: a subcommand, or a positional
• def parse.step.short.go`-` as a word, or a short option
• def parse.step.short`-` alone is a positional; otherwise a short option
• def parse.step.kind.go`--long` first, then `-s`, then a word
• def parse.step.kinda long option, a short option, or a word
• def parse.step.help`help` in command position collects the rest of argv as a path
• def parse.step.end`--` ends option parsing
• def parse.step.rawafter `--`, every token is a positional
• def parse.step.needa pending option value: a flag-shaped token is a missing value
• def parse.step.help_patha word after `help`: the subcommand it names, whose own subcommands the next word is looked up in, or an unexpected word
• def parse.step.modeone token against the walker