Enum broot::pattern::SearchMode

pub enum SearchMode {
    NameExact,
    NameFuzzy,
    NameRegex,
    NameTokens,
    PathExact,
    PathFuzzy,
    PathRegex,
    PathTokens,
    ContentExact,
    ContentRegex,
}

a valid combination of SearchObject and SearchKind, determine how a pattern will be used

Variants

NameExact

NameFuzzy

NameRegex

NameTokens

PathExact

PathFuzzy

PathRegex

PathTokens

ContentExact

ContentRegex

Implementations

impl SearchMode

pub fn prefix(self, con: &AppContext) -> String

Return the prefix to type, eg “/” in standard for a name-regex, “” for a name-fuzzy, and “ep” for a path-exact

Examples found in repository

src/help/help_search_modes.rs (line 18)

pub fn search_mode_help(mode: SearchMode, con: &AppContext) -> SearchModeHelp {
    let prefix = mode.prefix(con);
    let description = format!(
        "{} search on {}",
        match mode.kind() {
            SearchKind::Exact => "exact string",
            SearchKind::Fuzzy => "fuzzy",
            SearchKind::Regex => "regex",
            SearchKind::Tokens => "tokens",
        },
        match mode.object() {
            SearchObject::Name => "file name",
            SearchObject::Path => "sub path",
            SearchObject::Content => "file content",
        },
    );
    let example = match mode {
        SearchMode::NameExact => format!("`{prefix}feat` matches *help_features.rs*"),
        SearchMode::NameFuzzy => format!("`{prefix}conh` matches *DefaultConf.hjson*"),
        SearchMode::NameRegex => format!("`{prefix}rs$` matches *build.rs*"),
        SearchMode::NameTokens => format!("`{prefix}fea,he` matches *HelpFeature.java*"),
        SearchMode::PathExact => format!("`{prefix}te\\/do` matches *website/docs*"),
        SearchMode::PathFuzzy => format!("`{prefix}flam` matches *src/flag/mod.rs*"),
        SearchMode::PathRegex => format!(r#"`{prefix}\d{{3}}.*txt` matches *dir/a123/b.txt*"#),
        SearchMode::PathTokens => format!("`{prefix}help,doc` matches *website/docs/help.md*"),
        SearchMode::ContentExact => format!("`{prefix}find(` matches a file containing *a.find(b);*"),
        SearchMode::ContentRegex => format!("`{prefix}find/i` matches a file containing *A::Find(b)*"),
    };
    SearchModeHelp {
        prefix,
        description,
        example,
    }
}

src/help/help_state.rs (line 171)

    fn display(
        &mut self,
        w: &mut W,
        disc: &DisplayContext,
    ) -> Result<(), ProgramError> {
        let con = &disc.con;
        let mut text_area = disc.state_area.clone();
        text_area.pad_for_max_width(120);
        if text_area != self.text_area {
            self.dirty = true;
            self.text_area = text_area;
        }
        if self.dirty {
            disc.panel_skin.styles.default.queue_bg(w)?;
            disc.screen.clear_area_to_right(w, &disc.state_area)?;
            self.dirty = false;
        }
        let mut expander = help_content::expander();
        expander.set("version", env!("CARGO_PKG_VERSION"));
        let config_paths: Vec<String> = con.config_paths.iter()
            .map(|p| p.to_string_lossy().to_string())
            .collect();
        for path in &config_paths {
            expander.sub("config-files")
                .set("path", path);
        }
        let verb_rows = super::help_verbs::matching_verb_rows(&self.pattern, con);
        for row in &verb_rows {
            let sub = expander
                .sub("verb-rows")
                .set_md("name", row.name())
                .set_md("shortcut", row.shortcut())
                .set("key", &row.verb.keys_desc);
            if row.verb.description.code {
                sub.set("description", "");
                sub.set("execution", &row.verb.description.content);
            } else {
                sub.set_md("description", &row.verb.description.content);
                sub.set("execution", "");
            }
        }
        let mode_help;
        if let Ok(default_mode) = con.search_modes.search_mode(None) {
            mode_help = super::search_mode_help(default_mode, con);
            expander
                .sub("default-search")
                .set_md("default-search-example", &mode_help.example);
        }
        let search_rows: Vec<SearchModeHelp> = SEARCH_MODES
            .iter()
            .map(|mode| super::search_mode_help(*mode, con))
            .collect();
        for row in &search_rows {
            expander
                .sub("search-mode-rows")
                .set("search-prefix", &row.prefix)
                .set("search-type", &row.description)
                .set_md("search-example", &row.example);
        }
        let nr_prefix = SearchMode::NameRegex.prefix(con);
        let ce_prefix = SearchMode::ContentExact.prefix(con);
        expander
            .set("nr-prefix", &nr_prefix)
            .set("ce-prefix", &ce_prefix);
        let features = super::help_features::list();
        expander.set(
            "features-text",
            if features.is_empty() {
                "This release was compiled with no optional feature enabled."
            } else {
                "This release was compiled with those optional features enabled:"
            },
        );
        for feature in &features {
            expander
                .sub("features")
                .set("feature-name", feature.0)
                .set("feature-description", feature.1);
        }
        let text = expander.expand();
        let fmt_text = FmtText::from_text(
            &disc.panel_skin.help_skin,
            text,
            Some((self.text_area.width - 1) as usize),
        );
        let mut text_view = TextView::from(&self.text_area, &fmt_text);
        self.scroll = text_view.set_scroll(self.scroll);
        Ok(text_view.write_on(w)?)
    }

pub fn object(self) -> SearchObject

Examples found in repository

src/help/help_search_modes.rs (line 27)

pub fn search_mode_help(mode: SearchMode, con: &AppContext) -> SearchModeHelp {
    let prefix = mode.prefix(con);
    let description = format!(
        "{} search on {}",
        match mode.kind() {
            SearchKind::Exact => "exact string",
            SearchKind::Fuzzy => "fuzzy",
            SearchKind::Regex => "regex",
            SearchKind::Tokens => "tokens",
        },
        match mode.object() {
            SearchObject::Name => "file name",
            SearchObject::Path => "sub path",
            SearchObject::Content => "file content",
        },
    );
    let example = match mode {
        SearchMode::NameExact => format!("`{prefix}feat` matches *help_features.rs*"),
        SearchMode::NameFuzzy => format!("`{prefix}conh` matches *DefaultConf.hjson*"),
        SearchMode::NameRegex => format!("`{prefix}rs$` matches *build.rs*"),
        SearchMode::NameTokens => format!("`{prefix}fea,he` matches *HelpFeature.java*"),
        SearchMode::PathExact => format!("`{prefix}te\\/do` matches *website/docs*"),
        SearchMode::PathFuzzy => format!("`{prefix}flam` matches *src/flag/mod.rs*"),
        SearchMode::PathRegex => format!(r#"`{prefix}\d{{3}}.*txt` matches *dir/a123/b.txt*"#),
        SearchMode::PathTokens => format!("`{prefix}help,doc` matches *website/docs/help.md*"),
        SearchMode::ContentExact => format!("`{prefix}find(` matches a file containing *a.find(b);*"),
        SearchMode::ContentRegex => format!("`{prefix}find/i` matches a file containing *A::Find(b)*"),
    };
    SearchModeHelp {
        prefix,
        description,
        example,
    }
}

pub fn kind(self) -> SearchKind

Examples found in repository

src/help/help_search_modes.rs (line 21)

pub fn search_mode_help(mode: SearchMode, con: &AppContext) -> SearchModeHelp {
    let prefix = mode.prefix(con);
    let description = format!(
        "{} search on {}",
        match mode.kind() {
            SearchKind::Exact => "exact string",
            SearchKind::Fuzzy => "fuzzy",
            SearchKind::Regex => "regex",
            SearchKind::Tokens => "tokens",
        },
        match mode.object() {
            SearchObject::Name => "file name",
            SearchObject::Path => "sub path",
            SearchObject::Content => "file content",
        },
    );
    let example = match mode {
        SearchMode::NameExact => format!("`{prefix}feat` matches *help_features.rs*"),
        SearchMode::NameFuzzy => format!("`{prefix}conh` matches *DefaultConf.hjson*"),
        SearchMode::NameRegex => format!("`{prefix}rs$` matches *build.rs*"),
        SearchMode::NameTokens => format!("`{prefix}fea,he` matches *HelpFeature.java*"),
        SearchMode::PathExact => format!("`{prefix}te\\/do` matches *website/docs*"),
        SearchMode::PathFuzzy => format!("`{prefix}flam` matches *src/flag/mod.rs*"),
        SearchMode::PathRegex => format!(r#"`{prefix}\d{{3}}.*txt` matches *dir/a123/b.txt*"#),
        SearchMode::PathTokens => format!("`{prefix}help,doc` matches *website/docs/help.md*"),
        SearchMode::ContentExact => format!("`{prefix}find(` matches a file containing *a.find(b);*"),
        SearchMode::ContentRegex => format!("`{prefix}find/i` matches a file containing *A::Find(b)*"),
    };
    SearchModeHelp {
        prefix,
        description,
        example,
    }
}

Trait Implementations

impl Clone for SearchMode

fn clone(&self) -> SearchMode

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SearchMode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for SearchMode

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<SearchMode> for SearchMode

fn eq(&self, other: &SearchMode) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for SearchMode

impl Eq for SearchMode

impl StructuralEq for SearchMode

impl StructuralPartialEq for SearchMode