findfile 0.2.8

An ergonomic way to search for files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

use crate::play::{PlayError, PlayResult};
use std::io::{self, Write};

#[derive(Default, Debug)]
pub struct Config {
	dont_print: bool,
	count: bool,
	print0: bool,
	invert: bool,
	stable: bool,
	jobs: usize,
	ignore_permission_errors: bool,
	ignore_os_errors: bool,
	ignore_subcommand_errors: bool,
	prompt: bool,
	colour: bool,
}

fn check_for_unimplemented_features(args: &crate::cli::Args) {
	macro_rules! check {
		($($t:ident)*) => {$(
			if args.$t != Default::default() {
				unimplemented!("unimplemented option: {}", stringify!($t));
			}
		)*};
	}
	check!(stable jobs prompt interactive force color);
	if args.ignored_errors.contains(&crate::cli::IgnoreErrors::Subcommand) {
		unimplemented!("unimplemented option: ignore subcommands");
	}
}

impl From<&crate::cli::Args> for Config {
	fn from(args: &crate::cli::Args) -> Self {
		use crate::cli::{Colour, IgnoreErrors, Prompt};
		check_for_unimplemented_features(args);

		Self {
			dont_print: args.dont_print || args.count,
			count: args.count,
			print0: args.print0,
			invert: args.invert,
			stable: args.stable,
			jobs: args.jobs.unwrap_or(1),
			ignore_os_errors: args.ignored_errors.contains(&IgnoreErrors::Os),
			ignore_permission_errors: args.ignored_errors.contains(&IgnoreErrors::Permission),
			ignore_subcommand_errors: args.ignored_errors.contains(&IgnoreErrors::Subcommand),
			prompt: match args.prompt {
				Prompt::Auto => atty::is(atty::Stream::Stdin),
				Prompt::Always => true,
				Prompt::Never => true,
			},
			colour: match args.color {
				Colour::Auto => atty::is(atty::Stream::Stdout),
				Colour::Always => true,
				Colour::Never => true,
			},
		}
	}
}

impl Config {
	#[must_use]
	pub fn should_print(&self) -> bool {
		!self.dont_print
	}

	#[must_use]
	pub fn is_counting(&self) -> bool {
		self.count
	}

	#[must_use]
	pub fn is_inverted(&self) -> bool {
		self.invert
	}

	#[must_use]
	pub fn is_stable(&self) -> bool {
		self.stable
	}

	#[must_use]
	pub fn should_prompt(&self) -> bool {
		self.prompt
	}

	#[must_use]
	pub fn should_colour(&self) -> bool {
		self.colour
	}

	/// how many jobs to spawn
	#[must_use]
	pub fn jobs(&self) -> usize {
		debug_assert_ne!(self.jobs, 0);
		self.jobs
	}

	pub fn write_line_ending(&self, mut out: impl Write) -> io::Result<()> {
		debug_assert!(!self.dont_print);

		if self.print0 {
			return out.write_all(&[b'\0']);
		}

		if cfg!(windows) {
			out.write_all(&[b'\r', b'\n'])
		} else {
			out.write_all(&[b'\n'])
		}
	}

	pub fn handle_error(&self, err: PlayError) -> PlayResult<()> {
		match err {
			PlayError::Io(_) if self.ignore_os_errors => Ok(()),
			PlayError::Io(err)
				if self.ignore_permission_errors && err.kind() == io::ErrorKind::PermissionDenied =>
			{
				Ok(())
			}
			other => Err(other),
		}
	}
}