8d44459 · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

Add helix-specific ignore files (#8099)

8d44459Paul Olteanu3 years ago

helix-term/src/commands.rs+72−65

compare with master

unifiedsplit

@@ -2184,7 +2184,10 @@ fn global_search(cx: &mut Context) {

2184 let searcher = SearcherBuilder::new()

2185 .binary_detection(BinaryDetection::quit(b'\x00'))

2186 .build();

2187+

2187− WalkBuilder::new(search_root)

2188+ let mut walk_builder = WalkBuilder::new(search_root);

2189+

2190+ walk_builder

2188 .hidden(file_picker_config.hidden)

2191 .hidden(file_picker_config.hidden)

2189 .parents(file_picker_config.parents)

2192 .parents(file_picker_config.parents)

2190 .ignore(file_picker_config.ignore)

2193 .ignore(file_picker_config.ignore)

@@ -2195,73 +2198,77 @@ fn global_search(cx: &mut Context) {

2195 .max_depth(file_picker_config.max_depth)

2198 .max_depth(file_picker_config.max_depth)

2196 .filter_entry(move |entry| {

2199 .filter_entry(move |entry| {

2197 filter_picker_entry(entry, &absolute_root, dedup_symlinks)

2200 filter_picker_entry(entry, &absolute_root, dedup_symlinks)

2198− })

2201+ });

2199− .build_parallel()

2200− .run(|| {

2201− let mut searcher = searcher.clone();

2202− let matcher = matcher.clone();

2203− let injector = injector_.clone();

2204− let documents = &documents;

2205− Box::new(move |entry: Result<DirEntry, ignore::Error>| -> WalkState {

2206− let entry = match entry {

2207− Ok(entry) => entry,

2208− Err(_) => return WalkState::Continue,

2209− };

2210−

2211− match entry.file_type() {

2212− Some(entry) if entry.is_file() => {}

2213− // skip everything else

2214− _ => return WalkState::Continue,

2215− };

2216−

2217− let mut stop = false;

2218− let sink = sinks::UTF8(|line_num, _| {

2219− stop = injector

2220− .push(FileResult::new(entry.path(), line_num as usize - 1))

2221− .is_err();

2222−

2223− Ok(!stop)

2224− });

2225− let doc = documents.iter().find(|&(doc_path, _)| {

2226− doc_path

2227− .as_ref()

2228− .map_or(false, |doc_path| doc_path == entry.path())

2229− });

2230−

2231− let result = if let Some((_, doc)) = doc {

2232− // there is already a buffer for this file

2233− // search the buffer instead of the file because it's faster

2234− // and captures new edits without requiring a save

2235− if searcher.multi_line_with_matcher(&matcher) {

2236− // in this case a continous buffer is required

2237− // convert the rope to a string

2238− let text = doc.to_string();

2239− searcher.search_slice(&matcher, text.as_bytes(), sink)

2240− } else {

2241− searcher.search_reader(

2242− &matcher,

2243− RopeReader::new(doc.slice(..)),

2244− sink,

2245− )

2246− }

2247− } else {

2248− searcher.search_path(&matcher, entry.path(), sink)

2249− };

2250

2202

2251− if let Err(err) = result {

2203+ walk_builder

2252− log::error!(

2204+ .add_custom_ignore_filename(helix_loader::config_dir().join("ignore"));

2253− "Global search error: {}, {}",

2205+ walk_builder.add_custom_ignore_filename(".helix/ignore");

2254− entry.path().display(),

2206+

2255− err

2207+ walk_builder.build_parallel().run(|| {

2256− );

2208+ let mut searcher = searcher.clone();

2257− }

2209+ let matcher = matcher.clone();

2258− if stop {

2210+ let injector = injector_.clone();

2259− WalkState::Quit

2211+ let documents = &documents;

2212+ Box::new(move |entry: Result<DirEntry, ignore::Error>| -> WalkState {

2213+ let entry = match entry {

2214+ Ok(entry) => entry,

2215+ Err(_) => return WalkState::Continue,

2216+ };

2217+

2218+ match entry.file_type() {

2219+ Some(entry) if entry.is_file() => {}

2220+ // skip everything else

2221+ _ => return WalkState::Continue,

2222+ };

2223+

2224+ let mut stop = false;

2225+ let sink = sinks::UTF8(|line_num, _| {

2226+ stop = injector

2227+ .push(FileResult::new(entry.path(), line_num as usize - 1))

2228+ .is_err();

2229+

2230+ Ok(!stop)

2231+ });

2232+ let doc = documents.iter().find(|&(doc_path, _)| {

2233+ doc_path

2234+ .as_ref()

2235+ .map_or(false, |doc_path| doc_path == entry.path())

2236+ });

2237+

2238+ let result = if let Some((_, doc)) = doc {

2239+ // there is already a buffer for this file

2240+ // search the buffer instead of the file because it's faster

2241+ // and captures new edits without requiring a save

2242+ if searcher.multi_line_with_matcher(&matcher) {

2243+ // in this case a continous buffer is required

2244+ // convert the rope to a string

2245+ let text = doc.to_string();

2246+ searcher.search_slice(&matcher, text.as_bytes(), sink)

2260 } else {

2247 } else {

2261− WalkState::Continue

2248+ searcher.search_reader(

2249+ &matcher,

2250+ RopeReader::new(doc.slice(..)),

2251+ sink,

2252+ )

2262 }

2253 }

2263− })

2254+ } else {

2255+ searcher.search_path(&matcher, entry.path(), sink)

2256+ };

2257+

2258+ if let Err(err) = result {

2259+ log::error!(

2260+ "Global search error: {}, {}",

2261+ entry.path().display(),

2262+ err

2263+ );

2264+ }

2265+ if stop {

2266+ WalkState::Quit

2267+ } else {

2268+ WalkState::Continue

2269+ }

2264− });

2270+ })

2271+ });

2265 });

2272 });

2266

2273

2267 cx.jobs.callback(async move {

2274 cx.jobs.callback(async move {

helix-term/src/ui/mod.rs+3

@@ -177,6 +177,9 @@ pub fn file_picker(root: PathBuf, config: &helix_view::editor::Config) -> Picker

177 .max_depth(config.file_picker.max_depth)

178 .filter_entry(move |entry| filter_picker_entry(entry, &absolute_root, dedup_symlinks));

179

180+ walk_builder.add_custom_ignore_filename(helix_loader::config_dir().join("ignore"));

181+ walk_builder.add_custom_ignore_filename(".helix/ignore");

182+

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

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

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

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

182 type_builder

185 type_builder