+mod fuzzy_match;

+mod picker;

+mod prompt;

+use crate::compositor::{Component, Compositor};

+pub use picker::{FileLocation, FilePicker, Picker};

+use helix_core::regex::Regex;

+use helix_core::regex::RegexBuilder;

+use std::path::PathBuf;

+ fun: impl Fn(&mut Editor, Regex, PromptEvent) + 'static,

+ let offset_snapshot = view.offset;

+ view.offset = offset_snapshot;

+ match RegexBuilder::new(input)

+ .case_insensitive(case_insensitive)

+ .multi_line(true)

+ .build()

+ fun(cx.editor, regex, event);

+ view.offset = offset_snapshot;

+ let mut popup = Popup::new("invalid-regex", contents)

+ popup.required_size((size.width, size.height));

+

+ } else {

+ // Update

+ // TODO: mark command line as error

+ );

+pub fn file_picker(root: PathBuf, config: &helix_view::editor::Config) -> FilePicker<PathBuf> {

+ use ignore::{types::TypesBuilder, WalkBuilder};

+ walk_builder

+ // We always want to ignore the .git directory, otherwise if

+ // `ignore` is turned off above, we end up with a lot of noise

+ // in our picker.

+ .filter_entry(|entry| entry.file_name() != ".git");

+

+ // We want to exclude files that the editor can't handle yet

+ let mut type_builder = TypesBuilder::new();

+ type_builder

+ .add(

+ "compressed",

+ "*.{zip,gz,bz2,zst,lzo,sz,tgz,tbz2,lz,lz4,lzma,lzo,z,Z,xz,7z,rar,cab}",

+ )

+ .expect("Invalid type definition");

+ type_builder.negate("all");

+ let excluded_types = type_builder

+ .expect("failed to build excluded_types");

+ walk_builder.types(excluded_types);

+

+ // We want files along with their modification date for sorting

+ let files = walk_builder.build().filter_map(|entry| {

+ let entry = entry.ok()?;

+

+ // This is faster than entry.path().is_dir() since it uses cached fs::Metadata fetched by ignore/walkdir

+ let is_dir = entry.file_type().map_or(false, |ft| ft.is_dir());

+ if is_dir {

+ // Will give a false positive if metadata cannot be read (eg. permission error)

+ None

+ } else {

+ });

+ // Cap the number of files if we aren't in a git project, preventing

+ // hangs when using the picker in your home directory

+ let files: Vec<_> = if root.join(".git").exists() {

+ files.collect()

+ } else {

+ // const MAX: usize = 8192;

+ const MAX: usize = 100_000;

+ files.take(MAX).collect()

+ };

+ log::debug!("file_picker init {:?}", Instant::now().duration_since(now));

+ FilePicker::new(

+ files,

+ root,

+ move |cx, path: &PathBuf, action| {

+ if let Err(e) = cx.editor.open(path, action) {

+ |_editor, path| Some((path.clone().into(), None)),

+ use fuzzy_matcher::skim::SkimMatcherV2 as Matcher;

+ use fuzzy_matcher::FuzzyMatcher;

+ use std::cmp::Reverse;

+ let mut names: Vec<_> = editor

+ .documents

+ .values()

+ .map(|doc| {

+ let name = doc

+ .relative_path()

+ .map(|p| p.display().to_string())

+ .unwrap_or_else(|| String::from(SCRATCH_BUFFER_NAME));

+ ((0..), Cow::from(name))

+ })

+ .collect();

+

+ let matcher = Matcher::default();

+

+ let mut matches: Vec<_> = names

+ .filter_map(|(_range, name)| {

+ matcher.fuzzy_match(&name, input).map(|score| (name, score))

+ })

+ .collect();

+

+ matches.sort_unstable_by_key(|(_file, score)| Reverse(*score));

+ names = matches.into_iter().map(|(name, _)| ((0..), name)).collect();

+

+ names

+ let mut names = theme::Loader::read_names(&helix_loader::runtime_dir().join("themes"));

+ names.extend(theme::Loader::read_names(

+ &helix_loader::config_dir().join("themes"),

+ ));

+ let mut names: Vec<_> = names

+ .map(|name| ((0..), Cow::from(name)))

+ .collect();

+

+ let matcher = Matcher::default();

+

+ let mut matches: Vec<_> = names

+ .into_iter()

+ .filter_map(|(_range, name)| {

+ matcher.fuzzy_match(&name, input).map(|score| (name, score))

+ })

+ .collect();

+

+ matches.sort_unstable_by(|(name1, score1), (name2, score2)| {

+ (Reverse(*score1), name1).cmp(&(Reverse(*score2), name2))

+ });

+ names = matches.into_iter().map(|(name, _)| ((0..), name)).collect();

+

+ names

+ let matcher = Matcher::default();

+

+ let mut matches: Vec<_> = KEYS

+ .iter()

+ .filter_map(|name| matcher.fuzzy_match(name, input).map(|score| (name, score)))

+ .collect();

+

+ matches.sort_unstable_by_key(|(_file, score)| Reverse(*score));

+ matches

+ .map(|(name, _)| ((0..), name.into()))

+ filename_impl(editor, input, |entry| {

+ let is_dir = entry.file_type().map_or(false, |entry| entry.is_dir());

+ let matcher = Matcher::default();

+

+ let language_ids = editor

+ .syn_loader

+ let mut matches: Vec<_> = language_ids

+ .filter_map(|language_id| {

+ matcher

+ .fuzzy_match(language_id, input)

+ .map(|score| (language_id, score))

+ })

+ .collect();

+

+ matches.sort_unstable_by(|(language1, score1), (language2, score2)| {

+ (Reverse(*score1), language1).cmp(&(Reverse(*score2), language2))

+ });

+

+ matches

+ .map(|(language, _score)| ((0..), language.clone().into()))

+ let matcher = Matcher::default();

+

+ let (_, doc) = current_ref!(editor);

+ let language_server = match doc.language_server() {

+ Some(language_server) => language_server,

+ None => {

+ return vec![];

+ }

+ };

+

+ let options = match &language_server.capabilities().execute_command_provider {

+ Some(options) => options,

+ None => {

+ return vec![];

+ }

+ };

+

+ let mut matches: Vec<_> = options

+ .commands

+ .iter()

+ .filter_map(|command| {

+ matcher

+ .fuzzy_match(command, input)

+ .map(|score| (command, score))

+ })

+ .collect();

+

+ matches.sort_unstable_by(|(command1, score1), (command2, score2)| {

+ (Reverse(*score1), command1).cmp(&(Reverse(*score2), command2))

+ });

+

+ matches

+ .map(|(command, _score)| ((0..), command.clone().into()))

+ filename_impl(editor, input, |entry| {

+ let is_dir = entry.file_type().map_or(false, |entry| entry.is_dir());

+ pub fn help(_editor: &Editor, input: &str) -> Vec<Completion> {

+ let static_cmds_path = helix_loader::runtime_dir().join("help/static-commands");

+ let typable_cmds_path = helix_loader::runtime_dir().join("help/typable-commands");

+ let mut items: Vec<String> = std::fs::read_dir(static_cmds_path)

+ .map(|entries| {

+ entries

+ .filter_map(|entry| {

+ let entry = entry.ok()?;

+ let path = entry.path();

+ (path.extension()? == "md")

+ .then(|| path.file_stem().unwrap().to_string_lossy().into_owned())

+ })

+ .chain(

+ std::fs::read_dir(typable_cmds_path)

+ .map(|entries| {

+ entries.filter_map(|entry| {

+ let entry = entry.ok()?;

+ let path = entry.path();

+ (path.extension()? == "md").then(|| {

+ format!(":{}", path.file_stem().unwrap().to_string_lossy())

+ })

+ })

+ })

+ .into_iter()

+ .flatten(),

+ )

+ .collect()

+ })

+ .unwrap_or_default();

+ items.push("topics".to_owned());

+

+ let matcher = Matcher::default();

+

+ let mut matches: Vec<_> = items

+ .into_iter()

+ .map(Cow::from)

+ .filter_map(|name| matcher.fuzzy_match(&name, input).map(|score| (name, score)))

+ .collect();

+

+ matches.sort_unstable_by_key(|(_file, score)| Reverse(*score));

+

+ matches.into_iter().map(|(name, _)| ((0..), name)).collect()

+ }

+

+ fn filename_impl<F>(_editor: &Editor, input: &str, filter_fn: F) -> Vec<Completion>

+ let is_tilde = input.starts_with('~') && input.len() == 1;

+ let path = helix_core::path::expand_tilde(Path::new(input));

+ let file_name = path

+ .file_name()

+ .and_then(|file| file.to_str().map(|path| path.to_owned()));

+ let path = match path.parent() {

+ Some(path) if !path.as_os_str().is_empty() => path.to_path_buf(),

+ // Path::new("h")'s parent is Some("")...

+ _ => std::env::current_dir().expect("couldn't determine current directory"),

+ let mut files: Vec<_> = WalkBuilder::new(&dir)

+ //let is_dir = entry.file_type().map_or(false, |entry| entry.is_dir());

+ let path = path.to_str()?.to_owned();

+ Some((end.clone(), Cow::from(path)))

+ .filter(|(_, path)| !path.is_empty()) // TODO

+ .collect();

+ let matcher = Matcher::default();

+ // inefficient, but we need to calculate the scores, filter out None, then sort.

+ let mut matches: Vec<_> = files

+ .into_iter()

+ .filter_map(|(_range, file)| {

+ matcher

+ .fuzzy_match(&file, &file_name)

+ .map(|score| (file, score))

+ .collect();

+ let range = (input.len().saturating_sub(file_name.len()))..;

+ matches.sort_unstable_by(|(file1, score1), (file2, score2)| {

+ (Reverse(*score1), file1).cmp(&(Reverse(*score2), file2))

+ });

+ files = matches

+ .into_iter()

+ .map(|(file, _)| (range.clone(), file))

+ .collect();

+ // TODO: complete to longest common match

+ } else {

+ files.sort_unstable_by(|(_, path1), (_, path2)| path1.cmp(path2));

+ files