Struct aopt_help::format::DefaultAppPolicy

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

Implementations

impl<'a, I> DefaultAppPolicy<'a, I>

pub fn new(styles: Vec<Style>, show_global: bool) -> Self

Examples found in repository

src/lib.rs (line 262)

    pub fn display(&mut self, show_global: bool) -> Result<()> {
        let policy = DefaultAppPolicy::new(vec![], show_global);
        let help = policy.format(self).ok_or_else(|| {
            Error::raise("Can not format app help with DefaultAppPolicy".to_string())
        })?;

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

impl<'a, W: Write> DefaultAppPolicy<'a, AppHelp<'a, W>>

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 323)

    pub fn get_app_usage(&self, app: &AppHelp<'a, W>) -> Cow<'a, str> {
        let global = app.global();
        let mut usages = vec![];
        let mut args = vec![];
        let mut block_hint = vec![];

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

            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 global.block() {
            if !block.is_empty() {
                let arg = block.hint();

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

        let mut ret = String::from("Usage: ");
        // all the option usage
        let global_usage = usages.join(" ");
        let block_hint = block_hint.join(" ");
        let command_usage = if app.has_cmd() { "<COMMAND>" } else { "" };
        let args = args.join(" ");

        if !global.name().is_empty() {
            ret += &global.name();
            ret += " ";
        }
        if !global_usage.is_empty() {
            ret += &global_usage;
            ret += " ";
        }
        if !command_usage.is_empty() {
            ret += &command_usage;
            ret += " ";
        }
        if self.hiding_pos {
            if !block_hint.is_empty() {
                ret += &block_hint;
                ret += " ";
            }
        } else {
            if !args.is_empty() {
                ret += &args;
                ret += " ";
            }
        }
        ret.into()
    }

pub fn get_app_usage(&self, app: &AppHelp<'a, W>) -> Cow<'a, str>

Examples found in repository

src/format/policy.rs (line 545)

    fn format(&self, app: &AppHelp<'a, W>) -> Option<Cow<'a, str>> {
        let usage = self.get_app_usage(app);
        let head = app.head();
        let foot = app.foot();
        let block_spacing = "\n".repeat(1 + app.style().block_spacing);
        let mut usages = if usage.is_empty() {
            vec![]
        } else {
            vec![usage]
        };

        if !head.is_empty() {
            usages.push(head);
        }
        for block in app.block().iter() {
            let block_help = self.get_block_help(block, app);

            if !block_help.is_empty() {
                usages.push(block_help);
            }
        }
        if self.show_global {
            for block in app.global().block() {
                let global_help = self.get_global_help(block, app.global(), app);

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

pub fn get_block_help(
    &self,
    block: &Block<'a, Cow<'a, str>>,
    app: &AppHelp<'a, W>
) -> Cow<'a, str>

Examples found in repository

src/format/policy.rs (line 559)

    fn format(&self, app: &AppHelp<'a, W>) -> Option<Cow<'a, str>> {
        let usage = self.get_app_usage(app);
        let head = app.head();
        let foot = app.foot();
        let block_spacing = "\n".repeat(1 + app.style().block_spacing);
        let mut usages = if usage.is_empty() {
            vec![]
        } else {
            vec![usage]
        };

        if !head.is_empty() {
            usages.push(head);
        }
        for block in app.block().iter() {
            let block_help = self.get_block_help(block, app);

            if !block_help.is_empty() {
                usages.push(block_help);
            }
        }
        if self.show_global {
            for block in app.global().block() {
                let global_help = self.get_global_help(block, app.global(), app);

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

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

Examples found in repository

src/format/policy.rs (line 567)

    fn format(&self, app: &AppHelp<'a, W>) -> Option<Cow<'a, str>> {
        let usage = self.get_app_usage(app);
        let head = app.head();
        let foot = app.foot();
        let block_spacing = "\n".repeat(1 + app.style().block_spacing);
        let mut usages = if usage.is_empty() {
            vec![]
        } else {
            vec![usage]
        };

        if !head.is_empty() {
            usages.push(head);
        }
        for block in app.block().iter() {
            let block_help = self.get_block_help(block, app);

            if !block_help.is_empty() {
                usages.push(block_help);
            }
        }
        if self.show_global {
            for block in app.global().block() {
                let global_help = self.get_global_help(block, app.global(), app);

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

Trait Implementations

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

fn default() -> Self

Returns the “default value” for a type.

impl<'a, W: Write> HelpPolicy<'a, AppHelp<'a, W>> for DefaultAppPolicy<'a, AppHelp<'a, W>>

fn format(&self, app: &AppHelp<'a, W>) -> Option<Cow<'a, str>>