flynt 0.3.0

Lint Fluent translation keys against their use in Rust code and Askama templates
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

// src/report/mod.rs

//! Rendering a [`Report`].
//!
//! Nothing here writes to `stdout` directly. Every renderer takes an [`std::io::Write`] instead.
//! Tests can then assert on the output.

pub mod json;
pub mod text;

use std::io::Write;

use crate::config::{ColorChoice, Config, OutputFormat};
use crate::model::Report;

/// Renders the report in the configured format.
///
/// # Errors
///
/// Propagates write failures from `out`. Also propagates serialization failures from the JSON
/// renderer.
pub fn render(
	report: &Report,
	config: &Config,
	color: bool,
	out: &mut impl Write,
) -> std::io::Result<()> {
	match config.format {
		OutputFormat::Text => text::render(report, config, color, out),
		OutputFormat::Json => json::render(report, out),
	}
}

/// Decides whether to emit color.
///
/// `Auto` also honors `NO_COLOR`.
#[must_use]
pub fn color_enabled(choice: ColorChoice, is_terminal: bool) -> bool {
	match choice {
		ColorChoice::Always => true,
		ColorChoice::Never => false,
		ColorChoice::Auto => is_terminal && std::env::var_os("NO_COLOR").is_none(),
	}
}

/// ANSI escapes, switched off in one place.
pub(crate) struct Paint {
	on: bool,
}

impl Paint {
	pub(crate) fn new(on: bool) -> Self {
		Self { on }
	}

	fn wrap(&self, code: &str, text: &str) -> String {
		if self.on {
			format!("\x1b[{code}m{text}\x1b[0m")
		} else {
			text.to_owned()
		}
	}

	pub(crate) fn red(&self, text: &str) -> String {
		self.wrap("31", text)
	}

	pub(crate) fn green(&self, text: &str) -> String {
		self.wrap("32", text)
	}

	pub(crate) fn yellow(&self, text: &str) -> String {
		self.wrap("33", text)
	}

	pub(crate) fn bold(&self, text: &str) -> String {
		self.wrap("1", text)
	}

	pub(crate) fn dim(&self, text: &str) -> String {
		self.wrap("2", text)
	}

	/// Wraps `text` as underlined cyan, marking it as a source location.
	pub(crate) fn link(&self, text: &str) -> String {
		if self.on {
			format!("\x1b[4;36m{text}\x1b[0m")
		} else {
			text.to_owned()
		}
	}

	/// Wraps `prefix` and `suffix` in green, with `bold_part` bold in between.
	///
	/// A plain nested wrap would not work: the bold segment's reset code would also clear the
	/// surrounding green.
	pub(crate) fn green_bold(&self, prefix: &str, bold_part: &str, suffix: &str) -> String {
		if self.on {
			format!("\x1b[32m{prefix}\x1b[1m{bold_part}\x1b[0m\x1b[32m{suffix}\x1b[0m")
		} else {
			format!("{prefix}{bold_part}{suffix}")
		}
	}
}

/// `"1 key"` but `"2 keys"`.
pub(crate) fn plural(count: usize, singular: &str) -> String {
	if count == 1 {
		format!("{count} {singular}")
	} else {
		format!("{count} {singular}s")
	}
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn always_and_never_ignore_the_terminal() {
		assert!(color_enabled(ColorChoice::Always, false));
		assert!(!color_enabled(ColorChoice::Never, true));
	}

	#[test]
	fn auto_needs_a_terminal() {
		// NO_COLOR is not set in the test environment. A terminal decides instead.
		assert!(!color_enabled(ColorChoice::Auto, false));
	}

	#[test]
	fn paint_is_a_no_op_when_off() {
		let plain = Paint::new(false);
		assert_eq!(plain.red("x"), "x");
		assert_eq!(plain.bold("x"), "x");
	}

	#[test]
	fn paint_wraps_when_on() {
		let colored = Paint::new(true);
		assert_eq!(colored.red("x"), "\x1b[31mx\x1b[0m");
	}

	#[test]
	fn counts_are_pluralized() {
		assert_eq!(plural(0, "key"), "0 keys");
		assert_eq!(plural(1, "key"), "1 key");
		assert_eq!(plural(2, "key"), "2 keys");
	}
}