Method complete_opt

src/shell/helper.rs:102–146

(&self, line: &str)

    }

    fn complete_opt(&self, line: &str) -> Option<(usize, Vec<String>)> {
        let (startpos, words) = split_idents_on_dot(line)?;

        let (word_start, iter) = self.get_available_completions(&words)?;

        let all_completions = iter
            .filter(|res| {
                res.as_ref()
                    .ok()
                    .is_none_or(|s| s.as_bytes().starts_with(word_start.as_bytes()))
            })
            .collect::<Result<Vec<_>, _>>()
            .ok()?;
        let mut completions = if word_start.starts_with('_') {
            // if they're already looking for something starting with a '_', just give
            // them all the completions
            all_completions
        } else {
            // only the completions that don't start with a '_'
            let no_underscore = all_completions
                .iter()
                .filter(|&s| !s.as_bytes().starts_with(b"_"))
                .cloned()
                .collect::<Vec<_>>();

            // if there are only completions that start with a '_', give them all of the
            // completions, otherwise only the ones that don't start with '_'
            if no_underscore.is_empty() {
                all_completions
            } else {
                no_underscore
            }
        };

        // sort the completions alphabetically
        completions.sort_by(|a, b| a.as_wtf8().cmp(b.as_wtf8()));

        Some((
            startpos,
            completions
                .into_iter()
                .map(|s| s.expect_str().to_owned())
                .collect(),
        ))
    }
}

cfg_if::cfg_if! {