Struct conch_parser::ast::builder::DefaultBuilder

pub struct DefaultBuilder<T>(_);

A Builder implementation which builds shell commands using the (non-atomic) AST definitions in the ast module.

Methods

impl<T> DefaultBuilder<T>

fn new() -> Self

Constructs a builder.

Trait Implementations

impl<T> Debug for DefaultBuilder<T>

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T> Default for DefaultBuilder<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T> Clone for DefaultBuilder<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Copy for DefaultBuilder<T>

impl<T: From<String>> Builder for DefaultBuilder<T>

type Command = TopLevelCommand<T>

The type which represents a complete, top-level command.

type CommandList = AndOrList<Self::ListableCommand>

The type which represents an and/or list of commands.

type ListableCommand = ListableCommand<Self::PipeableCommand>

The type which represents a command that can be used in an and/or command list.

type PipeableCommand = ShellPipeableCommand<T, Self::Word, Self::Command>

The type which represents a command that can be used in a pipeline.

type CompoundCommand = ShellCompoundCommand<T, Self::Word, Self::Command>

The type which represents compound commands like if, case, for, etc.

type Word = TopLevelWord<T>

The type which represents shell words, which can be command names or arguments.

type Redirect = Redirect<Self::Word>

The type which represents a file descriptor redirection.

type Error = Void

A type for returning custom parse/build errors.

fn complete_command(
    &mut self,
    pre_cmd_comments: Vec<Newline>,
    list: Self::CommandList,
    separator: SeparatorKind,
    cmd_comment: Option<Newline>
) -> Result<Self::Command, Self::Error>

Invoked once a complete command is found. That is, a command delimited by a newline, semicolon, ampersand, or the end of input.

fn and_or_list(
    &mut self,
    first: Self::ListableCommand,
    rest: Vec<(Vec<Newline>, AndOr<Self::ListableCommand>)>
) -> Result<Self::CommandList, Self::Error>

Invoked when multiple commands are parsed which are separated by && or ||. Typically after the first command is run, each of the following commands may or may not be executed, depending on the exit status of the previously executed command.

fn pipeline(
    &mut self,
    bang: bool,
    cmds: Vec<(Vec<Newline>, Self::PipeableCommand)>
) -> Result<Self::ListableCommand, Self::Error>

Invoked when a pipeline of commands is parsed. A pipeline is one or more commands where the standard output of the previous typically becomes the standard input of the next.

fn simple_command(
    &mut self,
    redirects_or_env_vars: Vec<RedirectOrEnvVar<Self::Redirect, String, Self::Word>>,
    redirects_or_cmd_words: Vec<RedirectOrCmdWord<Self::Redirect, Self::Word>>
) -> Result<Self::PipeableCommand, Self::Error>

Invoked when the "simplest" possible command is parsed: an executable with arguments.

fn brace_group(
    &mut self,
    cmds: CommandGroup<Self::Command>,
    redirects: Vec<Self::Redirect>
) -> Result<Self::CompoundCommand, Self::Error>

Invoked when a non-zero number of commands were parsed between balanced curly braces. Typically these commands should run within the current shell environment.

fn subshell(
    &mut self,
    cmds: CommandGroup<Self::Command>,
    redirects: Vec<Self::Redirect>
) -> Result<Self::CompoundCommand, Self::Error>

Invoked when a non-zero number of commands were parsed between balanced parentheses. Typically these commands should run within their own environment without affecting the shell's global environment.

fn loop_command(
    &mut self,
    kind: LoopKind,
    guard_body_pair: GuardBodyPairGroup<Self::Command>,
    redirects: Vec<Self::Redirect>
) -> Result<Self::CompoundCommand, Self::Error>

Invoked when a loop command like while or until is parsed. Typically these commands will execute their body based on the exit status of their guard.

fn if_command(
    &mut self,
    fragments: IfFragments<Self::Command>,
    redirects: Vec<Self::Redirect>
) -> Result<Self::CompoundCommand, Self::Error>

Invoked when an if conditional command is parsed. Typically an if command is made up of one or more guard-body pairs, where the body of the first successful corresponding guard is executed. There can also be an optional else part to be run if no guard is successful.

fn for_command(
    &mut self,
    fragments: ForFragments<Self::Word, Self::Command>,
    redirects: Vec<Self::Redirect>
) -> Result<Self::CompoundCommand, Self::Error>

Invoked when a for command is parsed. Typically a for command binds a variable to each member in a group of words and invokes its body with that variable present in the environment. If no words are specified, the command will iterate over the arguments to the script or enclosing function.

fn case_command(
    &mut self,
    fragments: CaseFragments<Self::Word, Self::Command>,
    redirects: Vec<Self::Redirect>
) -> Result<Self::CompoundCommand, Self::Error>

Invoked when a case command is parsed. Typically this command will execute certain commands when a given word matches a pattern.

fn compound_command_into_pipeable(
    &mut self,
    cmd: Self::CompoundCommand
) -> Result<Self::PipeableCommand, Self::Error>

Bridges the gap between a PipeableCommand and a CompoundCommand since CompoundCommands are typically PipeableCommands as well.

fn function_declaration(
    &mut self,
    name: String,
    post_name_comments: Vec<Newline>,
    body: Self::CompoundCommand
) -> Result<Self::PipeableCommand, Self::Error>

Invoked when a function declaration is parsed. Typically a function declaration overwrites any previously defined function within the current environment.

fn comments(&mut self, comments: Vec<Newline>) -> Result<(), Self::Error>

Invoked when only comments are parsed with no commands following. This can occur if an entire shell script is commented out or if there are comments present at the end of the script.

fn word(
    &mut self,
    kind: ComplexWordKind<Self::Command>
) -> Result<Self::Word, Self::Error>

Invoked when a word is parsed.

fn redirect(
    &mut self,
    kind: RedirectKind<Self::Word>
) -> Result<Self::Redirect, Self::Error>

Invoked when a redirect is parsed.