PolytreeDE/alacritty
1
0
Fork 0
mirror of https://github.com/alacritty/alacritty.git synced 2025-10-30 23:36:53 -04:00
Code Releases Activity

Normalize Log Message Strings

Browse source 
The general style for errors, warnings and info messages is to start
with a capitalized letter and end without a period. The main exception
is when dealing with nouns that are clearer with special case handling,
e.g. "macOS failed to work" or "ioctl is borked".
This commit is contained in:
Nathan Lilienthal 2019-01-06 19:06:57 -05:00 • committed by Christian Duerr
parent dfc30eeef5
commit 04707cbba6
21 changed files with 197 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

1
CHANGELOG.md
View file

@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Changed
- Log messages are now consistent in style, and some have been removed
- Windows configuration location has been moved from %USERPROFILE%\alacritty.yml
to %APPDATA%\alacritty\alacritty.yml
- Windows default shell is now PowerShell instead of cmd

2
copypasta/src/windows.rs
View file

@ -13,7 +13,7 @@ pub enum Error {
impl ::std::error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::Clipboard(..) => "error opening clipboard",
Error::Clipboard(..) => "Error opening clipboard",
}
}
}

12
copypasta/src/x11.rs
View file

@ -35,9 +35,9 @@ impl ::std::error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::Io(..) => "error calling xclip",
Error::Xclip(..) => "error reported by xclip",
Error::Utf8(..) => "clipboard contents not utf8",
Error::Io(..) => "Error calling xclip",
Error::Xclip(..) => "Error reported by xclip",
Error::Utf8(..) => "Clipboard contents not utf8",
}
}
}
@ -50,11 +50,11 @@ impl ::std::fmt::Display for Error {
io::ErrorKind::NotFound => {
write!(f, "Please install `xclip` to enable clipboard support")
},
_ => write!(f, "error calling xclip: {}", err),
_ => write!(f, "Error calling xclip: {}", err),
}
},
Error::Xclip(ref s) => write!(f, "error from xclip: {}", s),
Error::Utf8(ref err) => write!(f, "error parsing xclip output: {}", err),
Error::Xclip(ref s) => write!(f, "Error from xclip: {}", s),
Error::Utf8(ref err) => write!(f, "Error parsing xclip output: {}", err),
}
}
}

11
font/src/darwin/mod.rs
View file

@ -101,9 +101,9 @@ pub enum Error {
impl ::std::error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::MissingGlyph(ref _c) => "couldn't find the requested glyph",
Error::MissingFont(ref _desc) => "couldn't find the requested font",
Error::FontNotLoaded => "tried to operate on font that hasn't been loaded",
Error::MissingGlyph(ref _c) => "Couldn't find the requested glyph",
Error::MissingFont(ref _desc) => "Couldn't find the requested font",
Error::FontNotLoaded => "Tried to operate on font that hasn't been loaded",
}
}
}
@ -129,7 +129,6 @@ impl ::Rasterize for Rasterizer {
type Err = Error;
fn new(device_pixel_ratio: f32, use_thin_strokes: bool) -> Result<Rasterizer, Error> {
info!("device_pixel_ratio: {}", device_pixel_ratio);
Ok(Rasterizer {
fonts: HashMap::new(),
keys: HashMap::new(),
@ -332,7 +331,7 @@ fn cascade_list_for_languages(
pub fn descriptors_for_family(family: &str) -> Vec<Descriptor> {
let mut out = Vec::new();
info!("family: {}", family);
trace!("Family: {}", family);
let ct_collection = match create_for_family(family) {
Some(c) => c,
None => return out,
@ -627,7 +626,7 @@ mod tests {
fn get_descriptors_and_build_font() {
let list = super::descriptors_for_family("Menlo");
assert!(!list.is_empty());
info!("{:?}", list);
println!("{:?}", list);
// Check to_font
let fonts = list.iter()

4
font/src/ft/fc/font_set.rs
View file

@ -63,7 +63,7 @@ impl<'a> IntoIterator for &'a FontSet {
(*self.as_ptr()).nfont as isize
};
info!("num fonts = {}", num_fonts);
trace!("Number of fonts is {}", num_fonts);
Iter {
font_set: self.deref(),
@ -81,7 +81,7 @@ impl<'a> IntoIterator for &'a FontSetRef {
(*self.as_ptr()).nfont as isize
};
info!("num fonts = {}", num_fonts);
trace!("Number of fonts is {}", num_fonts);
Iter {
font_set: self,

14
font/src/ft/mod.rs
View file

@ -117,7 +117,7 @@ impl ::Rasterize for FreeTypeRasterizer {
},
_ => {
// Fallback if font doesn't provide info about strikeout
trace!("No strikeout data available for font, using fallback.");
trace!("Using fallback strikeout metrics");
let strikeout_position = height as f32 / 2. + descent;
(strikeout_position, underline_thickness)
},
@ -267,7 +267,7 @@ impl FreeTypeRasterizer {
return Ok(Some(*key));
}
trace!("got font path={:?}", path);
trace!("Got font path={:?}", path);
let ft_face = self.library.new_face(&path, index)?;
// Get available pixel sizes if font isn't scalable.
@ -550,12 +550,12 @@ impl FreeTypeRasterizer {
// We've previously loaded this font, so don't
// load it again.
Some(&key) => {
debug!("Hit for font {:?}; no need to load.", path);
debug!("Hit for font {:?}; no need to load", path);
Ok(key)
},
None => {
debug!("Miss for font {:?}; loading now.", path);
debug!("Miss for font {:?}; loading now", path);
// Safe to unwrap the option since we've already checked for the path
// and index above.
let key = self.face_from_pattern(&pattern)?.unwrap();
@ -604,9 +604,9 @@ impl ::std::error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::FreeType(ref err) => err.description(),
Error::MissingFont(ref _desc) => "couldn't find the requested font",
Error::FontNotLoaded => "tried to operate on font that hasn't been loaded",
Error::MissingSizeMetrics => "tried to get size metrics from a face without a size",
Error::MissingFont(ref _desc) => "Couldn't find the requested font",
Error::FontNotLoaded => "Tried to operate on font that hasn't been loaded",
Error::MissingSizeMetrics => "Tried to get size metrics from a face without a size",
}
}
}

2
font/src/lib.rs
View file

@ -132,7 +132,7 @@ impl FontDesc {
impl fmt::Display for FontDesc {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "name '{}' and style '{}'", self.name, self.style)
write!(f, "name {} and style {}", self.name, self.style)
}
}

8
font/src/rusttype/mod.rs
View file

@ -166,10 +166,10 @@ pub enum Error {
impl ::std::error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::MissingFont(ref _desc) => "couldn't find the requested font",
Error::UnsupportedFont => "only TrueType fonts are supported",
Error::UnsupportedStyle => "the selected style is not supported by rusttype",
Error::MissingGlyph => "the selected font did not have the requested glyph",
Error::MissingFont(ref _desc) => "Couldn't find the requested font",
Error::UnsupportedFont => "Only TrueType fonts are supported",
Error::UnsupportedStyle => "The selected style is not supported by rusttype",
Error::MissingGlyph => "The selected font does not have the requested glyph",
}
}
}

2
src/ansi.rs
View file

@ -445,7 +445,7 @@ impl Mode {
1049 => Mode::SwapScreenAndSetRestoreCursor,
2004 => Mode::BracketedPaste,
_ => {
trace!("[unhandled] mode={:?}", num);
trace!("[unimplemented] primitive mode: {}", num);
return None
}
})

108
src/config.rs
View file

@ -73,7 +73,7 @@ fn deserialize_duration_ms<'a, D>(deserializer: D) -> ::std::result::Result<Dura
match u64::deserialize(deserializer) {
Ok(threshold_ms) => Ok(Duration::from_millis(threshold_ms)),
Err(err) => {
error!("problem with config: {}; Using default value", err);
error!("Problem with config: {}; using default value", err);
Ok(default_threshold_ms())
},
}
@ -171,7 +171,7 @@ fn deserialize_visual_bell_duration<'a, D>(deserializer: D) -> ::std::result::Re
match u16::deserialize(deserializer) {
Ok(duration) => Ok(duration),
Err(err) => {
error!("problem with config: {}; Using default value", err);
error!("Problem with config: {}; using default value", err);
Ok(0)
},
}
@ -320,19 +320,19 @@ impl<'de> Deserialize<'de> for Decorations {
"none" => Ok(Decorations::None),
"full" => Ok(Decorations::Full),
"true" => {
error!("deprecated decorations boolean value, \
error!("Deprecated decorations boolean value, \
use one of transparent|buttonless|none|full instead; \
Falling back to \"full\"");
falling back to \"full\"");
Ok(Decorations::Full)
},
"false" => {
error!("deprecated decorations boolean value, \
error!("Deprecated decorations boolean value, \
use one of transparent|buttonless|none|full instead; \
Falling back to \"none\"");
falling back to \"none\"");
Ok(Decorations::None)
},
_ => {
error!("invalid decorations value: {}; Using default value", value);
error!("Invalid decorations value: {}; using default value", value);
Ok(Decorations::Full)
}
}
@ -346,23 +346,23 @@ impl<'de> Deserialize<'de> for Decorations {
"none" => Ok(Decorations::None),
"full" => Ok(Decorations::Full),
"true" => {
error!("deprecated decorations boolean value, \
error!("Deprecated decorations boolean value, \
use one of none|full instead; \
Falling back to \"full\"");
falling back to \"full\"");
Ok(Decorations::Full)
},
"false" => {
error!("deprecated decorations boolean value, \
error!("Deprecated decorations boolean value, \
use one of none|full instead; \
Falling back to \"none\"");
falling back to \"none\"");
Ok(Decorations::None)
},
"transparent" | "buttonless" => {
error!("macos-only decorations value: {}; Using default value", value);
error!("macOS-only decorations value: {}; using default value", value);
Ok(Decorations::Full)
},
_ => {
error!("invalid decorations value: {}; Using default value", value);
error!("Invalid decorations value: {}; using default value", value);
Ok(Decorations::Full)
}
}
@ -406,7 +406,7 @@ fn deserialize_padding<'a, D>(deserializer: D) -> ::std::result::Result<Delta<u8
match Delta::deserialize(deserializer) {
Ok(delta) => Ok(delta),
Err(err) => {
error!("problem with config: {}; Using default value", err);
error!("Problem with config: {}; using default value", err);
Ok(default_padding())
},
}
@ -557,7 +557,7 @@ fn failure_default_vec<'a, D, T>(deserializer: D) -> ::std::result::Result<Vec<T
let vec = match Vec::<serde_yaml::Value>::deserialize(deserializer) {
Ok(vec) => vec,
Err(err) => {
error!("problem with config: {}; Using empty vector", err);
error!("Problem with config: {}; using empty vector", err);
return Ok(Vec::new());
},
};
@ -568,7 +568,7 @@ fn failure_default_vec<'a, D, T>(deserializer: D) -> ::std::result::Result<Vec<T
match T::deserialize(value) {
Ok(binding) => bindings.push(binding),
Err(err) => {
error!("problem with config: {}; Skipping value", err);
error!("Problem with config: {}; skipping value", err);
},
}
}
@ -586,7 +586,7 @@ fn deserialize_tabspaces<'a, D>(deserializer: D) -> ::std::result::Result<usize,
match usize::deserialize(deserializer) {
Ok(value) => Ok(value),
Err(err) => {
error!("problem with config: {}; Using `8`", err);
error!("Problem with config: {}; using 8", err);
Ok(default_tabspaces())
},
}
@ -598,7 +598,7 @@ fn default_true_bool<'a, D>(deserializer: D) -> ::std::result::Result<bool, D::E
match bool::deserialize(deserializer) {
Ok(value) => Ok(value),
Err(err) => {
error!("problem with config: {}; Using `true`", err);
error!("Problem with config: {}; using true", err);
Ok(true)
},
}
@ -612,7 +612,7 @@ fn failure_default<'a, D, T>(deserializer: D)
match T::deserialize(deserializer) {
Ok(value) => Ok(value),
Err(err) => {
error!("problem with config: {}; Using default value", err);
error!("Problem with config: {}; using default value", err);
Ok(T::default())
},
}
@ -675,8 +675,8 @@ fn deserialize_scrolling_history<'a, D>(deserializer: D) -> ::std::result::Resul
Ok(lines) => {
if lines > MAX_SCROLLBACK_LINES {
error!(
"problem with config: scrollback size is {}, but expected a maximum of {}; \
Using {1} instead",
"Problem with config: scrollback size is {}, but expected a maximum of {}; \
using {1} instead",
lines, MAX_SCROLLBACK_LINES,
);
Ok(MAX_SCROLLBACK_LINES)
@ -685,7 +685,7 @@ fn deserialize_scrolling_history<'a, D>(deserializer: D) -> ::std::result::Resul
}
},
Err(err) => {
error!("problem with config: {}; Using default value", err);
error!("Problem with config: {}; using default value", err);
Ok(default_scrolling_history())
},
}
@ -697,7 +697,7 @@ fn deserialize_scrolling_multiplier<'a, D>(deserializer: D) -> ::std::result::Re
match u8::deserialize(deserializer) {
Ok(lines) => Ok(lines),
Err(err) => {
error!("problem with config: {}; Using default value", err);
error!("Problem with config: {}; using default value", err);
Ok(default_scrolling_multiplier())
},
}
@ -739,7 +739,7 @@ impl<'a> de::Deserialize<'a> for ModsWrapper {
"Shift" => res.shift = true,
"Alt" | "Option" => res.alt = true,
"Control" => res.ctrl = true,
_ => error!("unknown modifier {:?}", modifier),
_ => error!("Unknown modifier {:?}", modifier),
}
}
@ -862,7 +862,7 @@ impl<'a> de::Deserialize<'a> for ModeWrapper {
"~AppCursor" => res.not_mode |= mode::TermMode::APP_CURSOR,
"AppKeypad" => res.mode |= mode::TermMode::APP_KEYPAD,
"~AppKeypad" => res.not_mode |= mode::TermMode::APP_KEYPAD,
_ => error!("unknown mode {:?}", modifier),
_ => error!("Unknown mode {:?}", modifier),
}
}
@ -1045,7 +1045,7 @@ impl<'a> de::Deserialize<'a> for RawBinding {
let scancode = val.as_u64().unwrap();
if scancode > u64::from(::std::u32::MAX) {
return Err(<V::Error as Error>::custom(format!(
"invalid key binding, scancode too big: {}",
"Invalid key binding, scancode too big: {}",
scancode
)));
}
@ -1225,9 +1225,9 @@ fn deserialize_color_index<'a, D>(deserializer: D) -> ::std::result::Result<u8,
Ok(index) => {
if index < 16 {
error!(
"problem with config: indexed_color's index is '{}', \
"Problem with config: indexed_color's index is {}, \
but a value bigger than 15 was expected; \
Ignoring setting",
ignoring setting",
index
);
@ -1238,7 +1238,7 @@ fn deserialize_color_index<'a, D>(deserializer: D) -> ::std::result::Result<u8,
}
},
Err(err) => {
error!("problem with config: {}; Ignoring setting", err);
error!("Problem with config: {}; ignoring setting", err);
// Return value out of range to ignore this color
Ok(0)
@ -1293,7 +1293,7 @@ fn deserialize_optional_color<'a, D>(deserializer: D) -> ::std::result::Result<O
},
Ok(None) => Ok(None),
Err(err) => {
error!("problem with config: {}; Using standard foreground color", err);
error!("Problem with config: {}; using standard foreground color", err);
Ok(None)
},
}
@ -1375,14 +1375,14 @@ fn rgb_from_hex<'a, D>(deserializer: D) -> ::std::result::Result<Rgb, D::Error>
type Value = Rgb;
fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.write_str("Hex colors spec like 'ffaabb'")
f.write_str("hex color like 0xff00ff")
}
fn visit_str<E>(self, value: &str) -> ::std::result::Result<Rgb, E>
where E: ::serde::de::Error
{
Rgb::from_str(&value[..])
.map_err(|_| E::custom("failed to parse rgb; expect 0xrrggbb"))
.map_err(|_| E::custom("failed to parse rgb; expected hex color like 0xff00ff"))
}
}
@ -1392,7 +1392,7 @@ fn rgb_from_hex<'a, D>(deserializer: D) -> ::std::result::Result<Rgb, D::Error>
match rgb {
Ok(rgb) => Ok(rgb),
Err(err) => {
error!("problem with config: {}; Using color #ff00ff", err);
error!("Problem with config: {}; using color #ff00ff", err);
Ok(Rgb { r: 255, g: 0, b: 255 })
},
}
@ -1444,8 +1444,8 @@ impl ::std::error::Error for Error {
fn description(&self) -> &str {
match *self {
Error::NotFound => "could not locate config file",
Error::Empty => "empty config file",
Error::NotFound => "Couldn't locate config file",
Error::Empty => "Empty config file",
Error::ReadingEnvHome(ref err) => err.description(),
Error::Io(ref err) => err.description(),
Error::Yaml(ref err) => err.description(),
@ -1458,10 +1458,10 @@ impl ::std::fmt::Display for Error {
match *self {
Error::NotFound | Error::Empty => write!(f, "{}", ::std::error::Error::description(self)),
Error::ReadingEnvHome(ref err) => {
write!(f, "could not read $HOME environment variable: {}", err)
write!(f, "Couldn't read $HOME environment variable: {}", err)
},
Error::Io(ref err) => write!(f, "error reading config file: {}", err),
Error::Yaml(ref err) => write!(f, "problem with config: {}", err),
Error::Io(ref err) => write!(f, "Error reading config file: {}", err),
Error::Yaml(ref err) => write!(f, "Problem with config: {}", err),
}
}
}
@ -1538,7 +1538,7 @@ impl Config {
if let Some(old_path) = old.as_ref().filter(|old| old.exists()) {
warn!(
"Found configuration at: '{}'. The file should be moved to the new location: '{}'.",
"Found configuration at: {}; this file should be moved to the new location: {}",
old_path.to_string_lossy(),
new.as_ref().map(|new| new.to_string_lossy()).unwrap(),
);
@ -1564,7 +1564,7 @@ impl Config {
pub fn write_defaults() -> io::Result<Cow<'static, Path>> {
let mut path = dirs::config_dir()
.ok_or_else(|| {
io::Error::new(io::ErrorKind::NotFound, "could not find profile directory")
io::Error::new(io::ErrorKind::NotFound, "Couldn't find profile directory")
}
)?;
@ -1765,21 +1765,22 @@ impl Config {
fn print_deprecation_warnings(&mut self) {
if self.dimensions.is_some() {
warn!("{}", "Config `dimensions` is deprecated. \
Please use `window.dimensions` instead.");
warn!("Config dimensions is deprecated; \
please use window.dimensions instead");
}
if self.padding.is_some() {
warn!("{}", "Config `padding` is deprecated. Please use `window.padding` instead.");
warn!("Config padding is deprecated; \
please use window.padding instead");
}
if self.mouse.faux_scrollback_lines.is_some() {
warn!("{}", "Config `mouse.faux_scrollback_lines` is deprecated. \
Please use `mouse.faux_scrolling_lines` instead.");
warn!("Config mouse.faux_scrollback_lines is deprecated; \
please use mouse.faux_scrolling_lines instead");
}
if let Some(custom_cursor_colors) = self.custom_cursor_colors {
warn!("{}", "Config `custom_cursor_colors` is deprecated.");
warn!("Config custom_cursor_colors is deprecated");
if !custom_cursor_colors {
self.colors.cursor.cursor = None;
@ -1788,17 +1789,18 @@ impl Config {
}
if self.cursor_style.is_some() {
warn!("{}", "Config `cursor_style` is deprecated. Please use `cursor.style` instead.");
warn!("Config cursor_style is deprecated; \
please use cursor.style instead");
}
if self.hide_cursor_when_typing.is_some() {
warn!("{}", "Config `hide_cursor_when_typing` is deprecated. \
Please use `mouse.hide_when_typing` instead.");
warn!("Config hide_cursor_when_typing is deprecated; \
please use mouse.hide_when_typing instead");
}
if self.unfocused_hollow_cursor.is_some() {
warn!("{}", "Config `unfocused_hollow_cursor` is deprecated. \
Please use `cursor.unfocused_hollow` instead.");
warn!("Config unfocused_hollow_cursor is deprecated; \
please use cursor.unfocused_hollow instead");
}
}
}
@ -1899,7 +1901,7 @@ impl DeserializeSize for Size {
match size {
Ok(size) => Ok(size),
Err(err) => {
error!("problem with config: {}; Using size 12", err);
error!("Problem with config: {}; using size 12", err);
Ok(Size::new(12.))
},
}
@ -1949,7 +1951,7 @@ where
{
// This is necessary in order to get serde to complete deserialization of the configuration
let _ignored = bool::deserialize(deserializer);
error!("The `scale_with_dpi` setting has been removed, \
error!("The scale_with_dpi setting has been removed, \
on X11 the WINIT_HIDPI_FACTOR environment variable can be used instead.");
Ok(None)
}

9
src/display.rs
View file

@ -144,7 +144,7 @@ impl Display {
let mut window = Window::new(&options, config.window())?;
let dpr = window.hidpi_factor();
info!("device_pixel_ratio: {}", dpr);
info!("Device pixel ratio: {}", dpr);
// get window properties for initializing the other subsystems
let mut viewport_size = window.inner_size_pixels()
@ -241,15 +241,16 @@ impl Display {
// Initialize glyph cache
let glyph_cache = {
info!("Initializing glyph cache");
info!("Initializing glyph cache...");
let init_start = ::std::time::Instant::now();
let cache =
renderer.with_loader(|mut api| GlyphCache::new(rasterizer, &font, &mut api))?;
let stop = init_start.elapsed();
let stop_f = stop.as_secs() as f64 + f64::from(stop.subsec_nanos()) / 1_000_000_000f64;
info!("Finished initializing glyph cache in {}", stop_f);
let stop_f = stop.as_secs() as f64 +
f64::from(stop.subsec_nanos()) / 1_000_000_000f64;
info!("... finished initializing glyph cache in {}s", stop_f);
cache
};

12
src/event_loop.rs
View file

@ -385,10 +385,10 @@ impl<T> EventLoop<T>
if let Err(err) = self.pty_read(&mut state, &mut buf, pipe.as_mut())
{
error!(
"Event loop exitting due to error: {} [{}:{}]",
err,
"[{}:{}] Event loop exiting due to error: {}",
file!(),
line!()
line!(),
err
);
break 'event_loop;
}
@ -401,10 +401,10 @@ impl<T> EventLoop<T>
if event.readiness().is_writable() {
if let Err(err) = self.pty_write(&mut state) {
error!(
"Event loop exitting due to error: {} [{}:{}]",
err,
"[{}:{}] Event loop exiting due to error: {}",
file!(),
line!()
line!(),
err
);
break 'event_loop;
}

4
src/grid/tests.rs
View file

@ -84,8 +84,6 @@ fn scroll_down() {
// Test that GridIterator works
#[test]
fn test_iter() {
info!("");
let mut grid = Grid::new(Line(5), Column(5), 0, 0);
for i in 0..5 {
for j in 0..5 {
@ -93,8 +91,6 @@ fn test_iter() {
}
}
info!("grid: {:?}", grid);
let mut iter = grid.iter_from(Point {
line: 4,
col: Column(0),

14
src/input.rs
View file

@ -224,7 +224,7 @@ impl Action {
.and_then(|clipboard| clipboard.load_primary() )
.map(|contents| { self.paste(ctx, &contents) })
.unwrap_or_else(|err| {
error!("Error loading data from clipboard. {}", Red(err));
error!("Error loading data from clipboard: {}", Red(err));
});
},
Action::PasteSelection => {
@ -234,19 +234,19 @@ impl Action {
.and_then(|clipboard| clipboard.load_selection() )
.map(|contents| { self.paste(ctx, &contents) })
.unwrap_or_else(|err| {
error!("Error loading data from clipboard. {}", Red(err));
error!("Error loading data from clipboard: {}", Red(err));
});
}
},
Action::Command(ref program, ref args) => {
trace!("running command: {} {:?}", program, args);
trace!("Running command {} with args {:?}", program, args);
match start_daemon(program, args) {
Ok(_) => {
debug!("spawned new proc");
debug!("Spawned new proc");
},
Err(err) => {
warn!("couldn't run command: {}", err);
warn!("Couldn't run command {}", err);
},
}
},
@ -546,8 +546,8 @@ impl<'a, A: ActionContext + 'a> Processor<'a, A> {
args.push(text);
match start_daemon(launcher.program(), &args) {
Ok(_) => debug!("Launched: {} {:?}", launcher.program(), args),
Err(_) => warn!("Unable to launch: {} {:?}", launcher.program(), args),
Ok(_) => debug!("Launched {} with args {:?}", launcher.program(), args),
Err(_) => warn!("Unable to launch {} with args {:?}", launcher.program(), args),
}
Some(())

27
src/logging.rs
View file

@ -125,13 +125,26 @@ impl log::Log for Logger {
}
fn log(&self, record: &log::Record<'_>) {
if self.enabled(record.metadata()) && record.target().starts_with("alacritty") {
let msg = format!(
"[{}] [{}] {}\n",
time::now().strftime("%F %R").unwrap(),
record.level(),
record.args()
);
if self.enabled(record.metadata()) &&
record.target().starts_with("alacritty")
{
let now = time::strftime("%F %R", &time::now()).unwrap();
let msg = if record.level() >= Level::Trace {
format!("[{}] [{}] [{}:{}] {}\n",
now,
record.level(),
record.file().unwrap_or("?"),
record.line()
.map(|l| l.to_string())
.unwrap_or("?".to_string()),
record.args())
} else {
format!("[{}] [{}] {}\n",
now,
record.level(),
record.args())
};
if let Ok(ref mut logfile) = self.logfile.lock() {
let _ = logfile.write_all(msg.as_ref());

10
src/main.rs
View file

@ -99,8 +99,8 @@ fn load_config(options: &cli::Options) -> Config {
Config::load_from(&*config_path).unwrap_or_else(|err| {
match err {
ConfigError::Empty => info!("Config file {:?} is empty; Loading default", config_path),
_ => error!("Error: {}; Loading default config", err),
ConfigError::Empty => info!("Config file {:?} is empty; loading default", config_path),
_ => error!("Error: {}; loading default config", err),
}
Config::default()
@ -116,9 +116,9 @@ fn run(
options: &cli::Options,
mut logger_proxy: LoggerProxy,
) -> Result<(), Box<dyn Error>> {
info!("Welcome to Alacritty.");
info!("Welcome to Alacritty");
if let Some(config_path) = config.path() {
info!("Configuration loaded from {}", config_path.display());
info!("Configuration loaded from {:?}", config_path.display());
};
// Set environment variables
@ -264,7 +264,7 @@ fn run(
#[cfg(windows)]
unsafe { FreeConsole(); }
info!("Goodbye.");
info!("Goodbye");
if !options.persistent_logging && !config.persistent_logging() {
logger_proxy.delete_log();

35
src/renderer/mod.rs
View file

@ -321,7 +321,7 @@ impl GlyphCache {
self.rasterizer.get_glyph(GlyphKey { font_key: regular, c: 'm', size: font.size() })?;
let metrics = self.rasterizer.metrics(regular, size)?;
info!("Font size changed: {:?} [DPR: {}]", font.size, dpr);
info!("Font size changed to {:?} with DPR of {}", font.size, dpr);
self.font_size = font.size;
self.font_key = regular;
@ -816,26 +816,15 @@ impl QuadRenderer {
}
pub fn reload_shaders(&mut self, size: PhysicalSize) {
warn!("Reloading shaders ...");
warn!("Reloading shaders...");
let result = (TextShaderProgram::new(size), RectShaderProgram::new());
let (program, rect_program) = match result {
(Ok(program), Ok(rect_program)) => {
warn!(" ... OK");
info!("... successfully reloaded shaders");
(program, rect_program)
}
(Err(err), _) | (_, Err(err)) => {
match err {
ShaderCreationError::Io(err) => {
error!("Error reading shader file: {}", err);
}
ShaderCreationError::Compile(path, log) => {
error!("Error compiling shader at {:?}\n{}", path, log);
}
ShaderCreationError::Link(log) => {
error!("Error reloading shaders: {}", log);
}
}
error!("{}", err);
return;
}
};
@ -1234,7 +1223,7 @@ impl TextShaderProgram {
);
let projection: [[f32; 4]; 4] = ortho.into();
info!("width: {}, height: {}", width, height);
info!("Width: {}, Height: {}", width, height);
unsafe {
gl::UniformMatrix4fv(
@ -1483,11 +1472,15 @@ impl ::std::error::Error for ShaderCreationError {
impl ::std::fmt::Display for ShaderCreationError {
fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
match *self {
ShaderCreationError::Io(ref err) => write!(f, "couldn't read shader: {}", err),
ShaderCreationError::Compile(ref _path, ref s) => {
write!(f, "failed compiling shader: {}", s)
}
ShaderCreationError::Link(ref s) => write!(f, "failed linking shader: {}", s),
ShaderCreationError::Io(ref err) => {
write!(f, "Couldn't read shader: {}", err)
},
ShaderCreationError::Compile(ref path, ref log) => {
write!(f, "Failed compiling shader at {}: {}", path.display(), log)
},
ShaderCreationError::Link(ref log) => {
write!(f, "Failed linking shader: {}", log)
},
}
}
}

100
src/term/mod.rs
View file

@ -1167,7 +1167,7 @@ impl Term {
/// Resize terminal to new dimensions
pub fn resize(&mut self, size : &SizeInfo) {
debug!("Term::resize");
debug!("Resizing terminal");
// Bounds check; lots of math assumes width and height are > 0
if size.width as usize <= 2 * self.size_info.padding_x as usize ||
@ -1224,7 +1224,7 @@ impl Term {
}
}
debug!("num_cols, num_lines = {}, {}", num_cols, num_lines);
debug!("New num_cols is {} and num_lines is {}", num_cols, num_lines);
// Resize grids to new size
self.grid.resize(num_lines, num_cols, &Cell::default());
@ -1276,7 +1276,7 @@ impl Term {
/// Expects origin to be in scroll range.
#[inline]
fn scroll_down_relative(&mut self, origin: Line, mut lines: Line) {
trace!("scroll_down_relative: origin={}, lines={}", origin, lines);
trace!("Scrolling down relative: origin={}, lines={}", origin, lines);
lines = min(lines, self.scroll_region.end - self.scroll_region.start);
lines = min(lines, self.scroll_region.end - origin);
@ -1290,7 +1290,7 @@ impl Term {
/// Expects origin to be in scroll range.
#[inline]
fn scroll_up_relative(&mut self, origin: Line, lines: Line) {
trace!("scroll_up_relative: origin={}, lines={}", origin, lines);
trace!("Scrolling up relative: origin={}, lines={}", origin, lines);
let lines = min(lines, self.scroll_region.end - self.scroll_region.start);
// Scroll from origin to bottom less number of lines
@ -1354,7 +1354,7 @@ impl ansi::Handler for Term {
return;
}
trace!("wrapping");
trace!("Wrapping input");
{
let location = Point {
@ -1434,7 +1434,7 @@ impl ansi::Handler for Term {
#[inline]
fn dectest(&mut self) {
trace!("dectest");
trace!("Dectesting");
let mut template = self.cursor.template;
template.c = 'E';
@ -1444,7 +1444,7 @@ impl ansi::Handler for Term {
#[inline]
fn goto(&mut self, line: Line, col: Column) {
trace!("goto: line={}, col={}", line, col);
trace!("Going to: line={}, col={}", line, col);
let (y_offset, max_y) = if self.mode.contains(mode::TermMode::ORIGIN) {
(self.scroll_region.start, self.scroll_region.end - 1)
} else {
@ -1458,13 +1458,13 @@ impl ansi::Handler for Term {
#[inline]
fn goto_line(&mut self, line: Line) {
trace!("goto_line: {}", line);
trace!("Going to line: {}", line);
self.goto(line, self.cursor.point.col)
}
#[inline]
fn goto_col(&mut self, col: Column) {
trace!("goto_col: {}", col);
trace!("Going to column: {}", col);
self.goto(self.cursor.point.line, col)
}
@ -1497,28 +1497,28 @@ impl ansi::Handler for Term {
#[inline]
fn move_up(&mut self, lines: Line) {
trace!("move_up: {}", lines);
trace!("Moving up: {}", lines);
let move_to = Line(self.cursor.point.line.0.saturating_sub(lines.0));
self.goto(move_to, self.cursor.point.col)
}
#[inline]
fn move_down(&mut self, lines: Line) {
trace!("move_down: {}", lines);
trace!("Moving down: {}", lines);
let move_to = self.cursor.point.line + lines;
self.goto(move_to, self.cursor.point.col)
}
#[inline]
fn move_forward(&mut self, cols: Column) {
trace!("move_forward: {}", cols);
trace!("Moving forward: {}", cols);
self.cursor.point.col = min(self.cursor.point.col + cols, self.grid.num_cols() - 1);
self.input_needs_wrap = false;
}
#[inline]
fn move_backward(&mut self, cols: Column) {
trace!("move_backward: {}", cols);
trace!("Moving backward: {}", cols);
self.cursor.point.col -= min(self.cursor.point.col, cols);
self.input_needs_wrap = false;
}
@ -1530,7 +1530,7 @@ impl ansi::Handler for Term {
#[inline]
fn device_status<W: io::Write>(&mut self, writer: &mut W, arg: usize) {
trace!("device status: {}", arg);
trace!("Reporting device status: {}", arg);
match arg {
5 => {
let _ = writer.write_all(b"\x1b[0n");
@ -1545,21 +1545,21 @@ impl ansi::Handler for Term {
#[inline]
fn move_down_and_cr(&mut self, lines: Line) {
trace!("move_down_and_cr: {}", lines);
trace!("Moving down and cr: {}", lines);
let move_to = self.cursor.point.line + lines;
self.goto(move_to, Column(0))
}
#[inline]
fn move_up_and_cr(&mut self, lines: Line) {
trace!("move_up_and_cr: {}", lines);
trace!("Moving up and cr: {}", lines);
let move_to = Line(self.cursor.point.line.0.saturating_sub(lines.0));
self.goto(move_to, Column(0))
}
#[inline]
fn put_tab(&mut self, mut count: i64) {
trace!("put_tab: {}", count);
trace!("Putting tab: {}", count);
while self.cursor.point.col < self.grid.num_cols() && count != 0 {
count -= 1;
@ -1587,7 +1587,7 @@ impl ansi::Handler for Term {
/// Backspace `count` characters
#[inline]
fn backspace(&mut self) {
trace!("backspace");
trace!("Backspace");
if self.cursor.point.col > Column(0) {
self.cursor.point.col -= 1;
self.input_needs_wrap = false;
@ -1597,7 +1597,7 @@ impl ansi::Handler for Term {
/// Carriage return
#[inline]
fn carriage_return(&mut self) {
trace!("carriage_return");
trace!("Carriage return");
self.cursor.point.col = Column(0);
self.input_needs_wrap = false;
}
@ -1605,7 +1605,7 @@ impl ansi::Handler for Term {
/// Linefeed
#[inline]
fn linefeed(&mut self) {
trace!("linefeed");
trace!("Linefeed");
let next = self.cursor.point.line + 1;
if next == self.scroll_region.end {
self.scroll_up(Line(1));
@ -1617,14 +1617,14 @@ impl ansi::Handler for Term {
/// Set current position as a tabstop
#[inline]
fn bell(&mut self) {
trace!("bell");
trace!("Bell");
self.visual_bell.ring();
self.next_is_urgent = Some(true);
}
#[inline]
fn substitute(&mut self) {
trace!("[unimplemented] substitute");
trace!("[unimplemented] Substitute");
}
/// Run LF/NL
@ -1660,7 +1660,7 @@ impl ansi::Handler for Term {
#[inline]
fn set_horizontal_tabstop(&mut self) {
trace!("set_horizontal_tabstop");
trace!("Setting horizontal tabstop");
let column = self.cursor.point.col;
self.tabs[column] = true;
}
@ -1679,7 +1679,7 @@ impl ansi::Handler for Term {
#[inline]
fn insert_blank_lines(&mut self, lines: Line) {
trace!("insert_blank_lines: {}", lines);
trace!("Inserting blank {} lines", lines);
if self.scroll_region.contains_(self.cursor.point.line) {
let origin = self.cursor.point.line;
self.scroll_down_relative(origin, lines);
@ -1688,7 +1688,7 @@ impl ansi::Handler for Term {
#[inline]
fn delete_lines(&mut self, lines: Line) {
trace!("delete_lines: {}", lines);
trace!("Deleting {} lines", lines);
if self.scroll_region.contains_(self.cursor.point.line) {
let origin = self.cursor.point.line;
self.scroll_up_relative(origin, lines);
@ -1697,7 +1697,7 @@ impl ansi::Handler for Term {
#[inline]
fn erase_chars(&mut self, count: Column) {
trace!("erase_chars: {}, {}", count, self.cursor.point.col);
trace!("Erasing chars: count={}, col={}", count, self.cursor.point.col);
let start = self.cursor.point.col;
let end = min(start + count, self.grid.num_cols() - 1);
@ -1737,7 +1737,7 @@ impl ansi::Handler for Term {
#[inline]
fn move_backward_tabs(&mut self, count: i64) {
trace!("move_backward_tabs: {}", count);
trace!("Moving backward {} tabs", count);
for _ in 0..count {
let mut col = self.cursor.point.col;
@ -1753,12 +1753,12 @@ impl ansi::Handler for Term {
#[inline]
fn move_forward_tabs(&mut self, count: i64) {
trace!("[unimplemented] move_forward_tabs: {}", count);
trace!("[unimplemented] Moving forward {} tabs", count);
}
#[inline]
fn save_cursor_position(&mut self) {
trace!("CursorSave");
trace!("Saving cursor position");
let cursor = if self.alt {
&mut self.cursor_save_alt
} else {
@ -1770,7 +1770,7 @@ impl ansi::Handler for Term {
#[inline]
fn restore_cursor_position(&mut self) {
trace!("CursorRestore");
trace!("Restoring cursor position");
let source = if self.alt {
&self.cursor_save_alt
} else {
@ -1784,7 +1784,7 @@ impl ansi::Handler for Term {
#[inline]
fn clear_line(&mut self, mode: ansi::LineClearMode) {
trace!("clear_line: {:?}", mode);
trace!("Clearing line: {:?}", mode);
let mut template = self.cursor.template;
template.flags ^= template.flags;
@ -1815,7 +1815,7 @@ impl ansi::Handler for Term {
/// Set the indexed color value
#[inline]
fn set_color(&mut self, index: usize, color: Rgb) {
trace!("set_color[{}] = {:?}", index, color);
trace!("Setting color[{}] = {:?}", index, color);
self.colors[index] = color;
self.color_modified[index] = true;
}
@ -1823,7 +1823,7 @@ impl ansi::Handler for Term {
/// Reset the indexed color to original value
#[inline]
fn reset_color(&mut self, index: usize) {
trace!("reset_color[{}]", index);
trace!("Reseting color[{}]", index);
self.colors[index] = self.original_colors[index];
self.color_modified[index] = false;
}
@ -1835,13 +1835,13 @@ impl ansi::Handler for Term {
Clipboard::new()
.and_then(|mut clipboard| clipboard.store_primary(string))
.unwrap_or_else(|err| {
warn!("Error storing selection to clipboard. {}", err);
warn!("Error storing selection to clipboard: {}", err);
});
}
#[inline]
fn clear_screen(&mut self, mode: ansi::ClearMode) {
trace!("clear_screen: {:?}", mode);
trace!("Clearing screen: {:?}", mode);
let mut template = self.cursor.template;
template.flags ^= template.flags;
@ -1881,7 +1881,7 @@ impl ansi::Handler for Term {
#[inline]
fn clear_tabs(&mut self, mode: ansi::TabulationClearMode) {
trace!("clear_tabs: {:?}", mode);
trace!("Clearing tabs: {:?}", mode);
match mode {
ansi::TabulationClearMode::Current => {
let column = self.cursor.point.col;
@ -1916,7 +1916,7 @@ impl ansi::Handler for Term {
#[inline]
fn reverse_index(&mut self) {
trace!("reverse_index");
trace!("Reversing index");
// if cursor is at the top
if self.cursor.point.line == self.scroll_region.start {
self.scroll_down(Line(1));
@ -1928,7 +1928,7 @@ impl ansi::Handler for Term {
/// set a terminal attribute
#[inline]
fn terminal_attribute(&mut self, attr: Attr) {
trace!("Set Attribute: {:?}", attr);
trace!("Setting attribute: {:?}", attr);
match attr {
Attr::Foreground(color) => self.cursor.template.fg = color,
Attr::Background(color) => self.cursor.template.bg = color,
@ -1959,7 +1959,7 @@ impl ansi::Handler for Term {
#[inline]
fn set_mode(&mut self, mode: ansi::Mode) {
trace!("set_mode: {:?}", mode);
trace!("Setting mode: {:?}", mode);
match mode {
ansi::Mode::SwapScreenAndSetRestoreCursor => {
self.mode.insert(mode::TermMode::ALT_SCREEN);
@ -1991,15 +1991,15 @@ impl ansi::Handler for Term {
ansi::Mode::Origin => self.mode.insert(mode::TermMode::ORIGIN),
ansi::Mode::DECCOLM => self.deccolm(),
ansi::Mode::Insert => self.mode.insert(mode::TermMode::INSERT), // heh
_ => {
trace!(".. ignoring set_mode");
ansi::Mode::BlinkingCursor => {
trace!("... unimplemented mode");
}
}
}
#[inline]
fn unset_mode(&mut self,mode: ansi::Mode) {
trace!("unset_mode: {:?}", mode);
trace!("Unsetting mode: {:?}", mode);
match mode {
ansi::Mode::SwapScreenAndSetRestoreCursor => {
self.mode.remove(mode::TermMode::ALT_SCREEN);
@ -2031,15 +2031,15 @@ impl ansi::Handler for Term {
ansi::Mode::Origin => self.mode.remove(mode::TermMode::ORIGIN),
ansi::Mode::DECCOLM => self.deccolm(),
ansi::Mode::Insert => self.mode.remove(mode::TermMode::INSERT),
_ => {
trace!(".. ignoring unset_mode");
ansi::Mode::BlinkingCursor => {
trace!("... unimplemented mode");
}
}
}
#[inline]
fn set_scrolling_region(&mut self, region: Range<Line>) {
trace!("set scroll region: {:?}", region);
trace!("Setting scrolling region: {:?}", region);
self.scroll_region.start = min(region.start, self.grid.num_lines());
self.scroll_region.end = min(region.end, self.grid.num_lines());
self.goto(Line(0), Column(0));
@ -2047,31 +2047,31 @@ impl ansi::Handler for Term {
#[inline]
fn set_keypad_application_mode(&mut self) {
trace!("set mode::TermMode::APP_KEYPAD");
trace!("Setting keypad application mode");
self.mode.insert(mode::TermMode::APP_KEYPAD);
}
#[inline]
fn unset_keypad_application_mode(&mut self) {
trace!("unset mode::TermMode::APP_KEYPAD");
trace!("Unsetting keypad application mode");
self.mode.remove(mode::TermMode::APP_KEYPAD);
}
#[inline]
fn configure_charset(&mut self, index: CharsetIndex, charset: StandardCharset) {
trace!("designate {:?} character set as {:?}", index, charset);
trace!("Configuring charset {:?} as {:?}", index, charset);
self.cursor.charsets[index] = charset;
}
#[inline]
fn set_active_charset(&mut self, index: CharsetIndex) {
trace!("Activate {:?} character set", index);
trace!("Setting active charset {:?}", index);
self.active_charset = index;
}
#[inline]
fn set_cursor_style(&mut self, style: Option<CursorStyle>) {
trace!("set_cursor_style {:?}", style);
trace!("Setting cursor style {:?}", style);
self.cursor_style = style;
}
}

2
src/tty/unix.rs
View file

@ -316,7 +316,7 @@ pub fn new<T: ToWinsize>(
pty
},
Err(err) => {
die!("Command::spawn() failed: {}", err);
die!("Failed to spawn command: {}", err);
}
}
}

4
src/tty/windows/mod.rs
View file

@ -85,10 +85,10 @@ pub fn new<'a>(
window_id: Option<usize>,
) -> Pty<'a> {
if let Some(pty) = conpty::new(config, options, size, window_id) {
info!("Using Conpty agent.");
info!("Using Conpty agent");
pty
} else {
info!("Using Winpty agent.");
info!("Using Winpty agent");
winpty::new(config, options, size, window_id)
}
}

8
winpty/src/windows.rs
View file

@ -140,8 +140,8 @@ impl<'a> Drop for Config<'a> {
pub struct Winpty<'a>(&'a mut winpty_t);
impl<'a, 'b> Winpty<'a> {
/// Starts the agent. This process will connect to the agent
/// over a control pipe, and the agent will open data pipes
/// Starts the agent. This process will connect to the agent
/// over a control pipe, and the agent will open data pipes
/// (e.g. CONIN and CONOUT).
pub fn open(cfg: &Config) -> Result<Self, Err<'b>> {
let mut err = null_mut() as *mut winpty_error_t;
@ -199,7 +199,7 @@ impl<'a, 'b> Winpty<'a> {
}
/// Change the size of the Windows console window.
///
///
/// cols & rows MUST be greater than 0
pub fn set_size(&mut self, cols: u16, rows: u16) -> Result<(), Err> {
assert!(cols > 0 && rows > 0);
@ -339,7 +339,7 @@ impl<'a> Drop for SpawnConfig<'a> {
}
}
}
#[cfg(test)]
mod tests {
extern crate named_pipe;