Struct aopt_help::prelude::DefaultPolicy

pub struct DefaultPolicy<'a, I> { /* private fields */ }

Implementations

impl<'a, I> DefaultPolicy<'a, I>

pub fn new<S: Into<Cow<'a, str>>>(
    name: S,
    style: Style,
    block: Vec<Style>,
    hiding_pos: bool
) -> Self

Examples found in repository

src/lib.rs (line 291)

    pub fn display_cmd<S>(&mut self, cmd: S) -> Result<()>
    where
        S: Into<Cow<'a, str>>,
    {
        let name = cmd.into();
        let cmd = self.cmds.iter().find(|v| v.name() == name).ok_or_else(|| {
            Error::raise(format!("Can not format help of {name} with DefaultPolicy"))
        })?;
        let policy = DefaultPolicy::new(self.name(), self.style.clone(), vec![], true);
        let help = policy.format(cmd).ok_or_else(|| todo!())?;

        writeln!(&mut self.writer, "{}", help)
            .map_err(|e| Error::raise(format!("Can not write to handler: {:?}", e)))
    }

impl<'a> DefaultPolicy<'a, Command<'a>>

pub fn get_block_usage(
    &self,
    item: &Block<'a, Cow<'a, str>>,
    stores: &[Store<'a>]
) -> (Vec<String>, Vec<String>)

Examples found in repository

src/format/policy.rs (line 91)

    pub fn get_command_usage(&self, item: &Command<'a>) -> Cow<'a, str> {
        let mut usages = vec![];
        let mut args = vec![];
        let mut block_hint = vec![];

        for block in item.block() {
            let (mut block_usages, mut block_args) = self.get_block_usage(block, item);

            if !block_usages.is_empty() {
                usages.append(&mut block_usages);
            }
            // if not omit args, using the args, otherwise using hint of block
            if !block_args.is_empty() {
                args.append(&mut block_args);
            }
        }
        for block in item.block() {
            let arg = block.hint();

            if !arg.is_empty() {
                block_hint.push(arg);
            }
        }

        let usage = usages.join(" ");
        let args = if self.hiding_pos {
            "".to_owned()
        } else {
            args.join(" ")
        };
        let block_hint = block_hint.join(" ");

        let ret = if self.hiding_pos {
            format!(
                "Usage: {} {} {} {}",
                self.name,
                item.name(),
                usage,
                block_hint
            )
        } else {
            format!("Usage: {} {} {} {}", self.name, item.name(), usage, args)
        };

        ret.into()
    }

pub fn get_command_usage(&self, item: &Command<'a>) -> Cow<'a, str>

Examples found in repository

src/format/policy.rs (line 215)

    fn format(&self, item: &Command<'a>) -> Option<Cow<'a, str>> {
        let usage = self.get_command_usage(item);
        let mut blocks = vec![usage];
        let head = item.head();
        let foot = item.foot();
        let block_spacing = "\n".repeat(1 + self.style.block_spacing);

        if !head.is_empty() {
            blocks.push(head);
        }
        for block in item.block() {
            let help = self.get_block_help(block, item);

            if !help.is_empty() {
                blocks.push(help);
            }
        }
        if !foot.is_empty() {
            blocks.push(foot);
        }
        Some(blocks.join(&block_spacing).into())
    }

pub fn get_block_help(
    &self,
    item: &Block<'a, Cow<'a, str>>,
    stores: &Vec<Store<'a>>
) -> Cow<'a, str>

Examples found in repository

src/format/policy.rs (line 225)

    fn format(&self, item: &Command<'a>) -> Option<Cow<'a, str>> {
        let usage = self.get_command_usage(item);
        let mut blocks = vec![usage];
        let head = item.head();
        let foot = item.foot();
        let block_spacing = "\n".repeat(1 + self.style.block_spacing);

        if !head.is_empty() {
            blocks.push(head);
        }
        for block in item.block() {
            let help = self.get_block_help(block, item);

            if !help.is_empty() {
                blocks.push(help);
            }
        }
        if !foot.is_empty() {
            blocks.push(foot);
        }
        Some(blocks.join(&block_spacing).into())
    }

Trait Implementations

impl<'a, I> Default for DefaultPolicy<'a, I>

fn default() -> Self

Returns the “default value” for a type.

impl<'a> HelpPolicy<'a, Command<'a>> for DefaultPolicy<'a, Command<'a>>

fn format(&self, item: &Command<'a>) -> Option<Cow<'a, str>>