s3rius/squeekboard
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

logging: Unified to remove random eprint calls

Browse Source
This commit is contained in:
Dorota Czaplejewicz
2020-01-17 12:25:39 +00:00
parent cc418c3609
commit c75e085dc8
10 changed files with 130 additions and 56 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/data.rs
View File

@ -190,11 +190,13 @@ fn load_layout_data_with_fallback(
( (
LoadError::BadData(Error::Missing(e)), LoadError::BadData(Error::Missing(e)),
DataSource::File(file) DataSource::File(file)
) => eprintln!( // TODO: print in debug logging level ) => log_print!(
logging::Level::Debug,
"Tried file {:?}, but it's missing: {}", "Tried file {:?}, but it's missing: {}",
file, e file, e
), ),
(e, source) => eprintln!( (e, source) => log_print!(
logging::Level::Warning,
"Failed to load layout from {}: {}, skipping", "Failed to load layout from {}: {}, skipping",
source, e source, e
), ),

32
src/imservice.rs
View File

@ -4,10 +4,12 @@ use std::fmt;
use std::num::Wrapping; use std::num::Wrapping;
use std::string::String; use std::string::String;
use ::logging;
use ::util::c::into_cstring; use ::util::c::into_cstring;
// Traits // Traits
use std::convert::TryFrom; use std::convert::TryFrom;
use ::logging::Warn;
/// Gathers stuff defined in C or called by C /// Gathers stuff defined in C or called by C
@ -102,16 +104,20 @@ pub mod c {
let imservice = check_imservice(imservice, im).unwrap(); let imservice = check_imservice(imservice, im).unwrap();
imservice.pending = IMProtocolState { imservice.pending = IMProtocolState {
content_hint: { content_hint: {
ContentHint::from_bits(hint).unwrap_or_else(|| { ContentHint::from_bits(hint)
eprintln!("Warning: received invalid hint flags"); .or_print(
ContentHint::NONE logging::Problem::Warning,
}) "Received invalid hint flags",
)
.unwrap_or(ContentHint::NONE)
}, },
content_purpose: { content_purpose: {
ContentPurpose::try_from(purpose).unwrap_or_else(|_e| { ContentPurpose::try_from(purpose)
eprintln!("Warning: Received invalid purpose value"); .or_print(
ContentPurpose::Normal logging::Problem::Warning,
}) "Received invalid purpose value",
)
.unwrap_or(ContentPurpose::Normal)
}, },
..imservice.pending.clone() ..imservice.pending.clone()
}; };
@ -126,10 +132,12 @@ pub mod c {
let imservice = check_imservice(imservice, im).unwrap(); let imservice = check_imservice(imservice, im).unwrap();
imservice.pending = IMProtocolState { imservice.pending = IMProtocolState {
text_change_cause: { text_change_cause: {
ChangeCause::try_from(cause).unwrap_or_else(|_e| { ChangeCause::try_from(cause)
eprintln!("Warning: received invalid cause value"); .or_print(
ChangeCause::InputMethod logging::Problem::Warning,
}) "Received invalid cause value",
)
.unwrap_or(ChangeCause::InputMethod)
}, },
..imservice.pending.clone() ..imservice.pending.clone()
}; };

8
src/keyboard.rs
View File

@ -7,6 +7,7 @@ use std::io;
use std::string::FromUtf8Error; use std::string::FromUtf8Error;
use ::action::Action; use ::action::Action;
use ::logging;
use std::io::Write; use std::io::Write;
use std::iter::{ FromIterator, IntoIterator }; use std::iter::{ FromIterator, IntoIterator };
@ -110,7 +111,12 @@ pub fn generate_keymap(
for (name, state) in keystates.iter() { for (name, state) in keystates.iter() {
if let Action::Submit { text: _, keys } = &state.action { if let Action::Submit { text: _, keys } = &state.action {
if let 0 = keys.len() { eprintln!("Key {} has no keysyms", name); }; if let 0 = keys.len() {
log_print!(
logging::Level::Warning,
"Key {} has no keysyms", name,
);
};
for (named_keysym, keycode) in keys.iter().zip(&state.keycodes) { for (named_keysym, keycode) in keys.iter().zip(&state.keycodes) {
write!( write!(
buf, buf,

34
src/layout.rs
View File

@ -20,17 +20,21 @@
use std::cell::RefCell; use std::cell::RefCell;
use std::collections::{ HashMap, HashSet }; use std::collections::{ HashMap, HashSet };
use std::ffi::CString; use std::ffi::CString;
use std::fmt;
use std::rc::Rc; use std::rc::Rc;
use std::vec::Vec; use std::vec::Vec;
use ::action::Action; use ::action::Action;
use ::drawing; use ::drawing;
use ::keyboard::{ KeyState, PressType }; use ::keyboard::{ KeyState, PressType };
use ::logging;
use ::manager; use ::manager;
use ::submission::{ Timestamp, VirtualKeyboard }; use ::submission::{ Timestamp, VirtualKeyboard };
use ::util::find_max_double; use ::util::find_max_double;
// Traits
use std::borrow::Borrow; use std::borrow::Borrow;
use ::logging::Warn;
/// Gathers stuff defined in C or called by C /// Gathers stuff defined in C or called by C
pub mod c { pub mod c {
@ -623,6 +627,12 @@ pub struct LayoutData {
#[derive(Debug)] #[derive(Debug)]
struct NoSuchView; struct NoSuchView;
impl fmt::Display for NoSuchView {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "No such view")
}
}
// Unfortunately, changes are not atomic due to mutability :( // Unfortunately, changes are not atomic due to mutability :(
// An error will not be recoverable // An error will not be recoverable
// The usage of &mut on Rc<RefCell<KeyState>> doesn't mean anything special. // The usage of &mut on Rc<RefCell<KeyState>> doesn't mean anything special.
@ -660,7 +670,10 @@ impl Layout {
time: Timestamp, time: Timestamp,
) { ) {
if !self.pressed_keys.insert(::util::Pointer(rckey.clone())) { if !self.pressed_keys.insert(::util::Pointer(rckey.clone())) {
eprintln!("Warning: key {:?} was already pressed", rckey); log_print!(
logging::Level::Bug,
"Key {:?} was already pressed", rckey,
);
} }
let mut key = rckey.borrow_mut(); let mut key = rckey.borrow_mut();
virtual_keyboard.switch( virtual_keyboard.switch(
@ -806,9 +819,10 @@ mod seat {
fn try_set_view(layout: &mut Layout, view_name: String) { fn try_set_view(layout: &mut Layout, view_name: String) {
layout.set_view(view_name.clone()) layout.set_view(view_name.clone())
.map_err(|e| .or_print(
eprintln!("Bad view {} ({:?}), ignoring", view_name, e) logging::Problem::Bug,
).ok(); &format!("Bad view {}, ignoring", view_name),
);
} }
/// A vessel holding an obligation to switch view. /// A vessel holding an obligation to switch view.
@ -850,9 +864,10 @@ mod seat {
Action::LockView { lock: _, unlock: view } => { Action::LockView { lock: _, unlock: view } => {
new_view = Some(view.clone()); new_view = Some(view.clone());
}, },
a => eprintln!( a => log_print!(
"BUG: action {:?} was found inside locked keys", logging::Level::Bug,
a "Non-locking action {:?} was found inside locked keys",
a,
), ),
}; };
key.locked = false; key.locked = false;
@ -937,7 +952,10 @@ mod seat {
} }
} }
}, },
Action::SetModifier(_) => eprintln!("Modifiers unsupported"), Action::SetModifier(_) => log_print!(
logging::Level::Bug,
"Modifiers unsupported",
),
}; };
let pointer = ::util::Pointer(rckey.clone()); let pointer = ::util::Pointer(rckey.clone());

4
src/lib.rs
View File

@ -15,6 +15,9 @@ extern crate regex;
extern crate serde; extern crate serde;
extern crate xkbcommon; extern crate xkbcommon;
#[macro_use]
mod logging;
mod action; mod action;
pub mod data; pub mod data;
mod drawing; mod drawing;
@ -24,7 +27,6 @@ mod keyboard;
mod layout; mod layout;
mod locale; mod locale;
mod locale_config; mod locale_config;
mod logging;
mod manager; mod manager;
mod outputs; mod outputs;
mod popover; mod popover;

7
src/locale.rs
View File

@ -8,6 +8,7 @@
use std::cmp; use std::cmp;
use std::ffi::{ CStr, CString }; use std::ffi::{ CStr, CString };
use std::fmt;
use std::os::raw::c_char; use std::os::raw::c_char;
use std::ptr; use std::ptr;
use std::str::Utf8Error; use std::str::Utf8Error;
@ -47,6 +48,12 @@ pub enum Error {
NoInfo, NoInfo,
} }
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&self, f)
}
}
pub struct XkbInfo(c::GnomeXkbInfo); pub struct XkbInfo(c::GnomeXkbInfo);
impl XkbInfo { impl XkbInfo {

14
src/logging.rs
View File

@ -108,8 +108,20 @@ pub enum Problem {
Surprise, Surprise,
} }
/// Sugar for approach 2
// TODO: avoid, deprecate.
// Handler instances should be long lived, not one per call.
macro_rules! log_print {
($level:expr, $($arg:tt)*) => (::logging::print($level, &format!($($arg)*)))
}
/// Approach 2
pub fn print(level: Level, message: &str) {
Print{}.handle(level, message)
}
/// Sugar for logging errors in results. /// Sugar for logging errors in results.
pub trait Warn where Self: Sized{ pub trait Warn where Self: Sized {
type Value; type Value;
/// Approach 2. /// Approach 2.
fn or_print(self, level: Problem, message: &str) -> Option<Self::Value> { fn or_print(self, level: Problem, message: &str) -> Option<Self::Value> {

51
src/outputs.rs
View File

@ -1,7 +1,10 @@
/*! Managing Wayland outputs */ /*! Managing Wayland outputs */
use std::vec::Vec; use std::vec::Vec;
use ::logging;
// traits
use ::logging::Warn;
/// Gathers stuff defined in C or called by C /// Gathers stuff defined in C or called by C
pub mod c { pub mod c {
@ -113,14 +116,11 @@ pub mod c {
_make: *const c_char, _model: *const c_char, _make: *const c_char, _model: *const c_char,
transform: i32, transform: i32,
) { ) {
let transform = Transform::from_u32(transform as u32).unwrap_or_else( let transform = Transform::from_u32(transform as u32)
|| { .or_print(
eprintln!( logging::Problem::Warning,
"Warning: received invalid wl_output.transform value" "Received invalid wl_output.transform value",
); ).unwrap_or(Transform::Normal);
Transform::Normal
}
);
let outputs = outputs.clone_ref(); let outputs = outputs.clone_ref();
let mut collection = outputs.borrow_mut(); let mut collection = outputs.borrow_mut();
@ -129,7 +129,10 @@ pub mod c {
.map(|o| &mut o.pending); .map(|o| &mut o.pending);
match output_state { match output_state {
Some(state) => { state.transform = Some(transform) }, Some(state) => { state.transform = Some(transform) },
None => eprintln!("Wayland error: Got mode on unknown output"), None => log_print!(
logging::Level::Warning,
"Got geometry on unknown output",
),
}; };
} }
@ -141,10 +144,12 @@ pub mod c {
height: i32, height: i32,
_refresh: i32, _refresh: i32,
) { ) {
let flags = Mode::from_bits(flags).unwrap_or_else(|| { let flags = Mode::from_bits(flags)
eprintln!("Warning: received invalid wl_output.mode flags"); .or_print(
Mode::NONE logging::Problem::Warning,
}); "Received invalid wl_output.mode flags",
).unwrap_or(Mode::NONE);
let outputs = outputs.clone_ref(); let outputs = outputs.clone_ref();
let mut collection = outputs.borrow_mut(); let mut collection = outputs.borrow_mut();
let output_state: Option<&mut OutputState> let output_state: Option<&mut OutputState>
@ -156,7 +161,10 @@ pub mod c {
state.current_mode = Some(super::Mode { width, height}); state.current_mode = Some(super::Mode { width, height});
} }
}, },
None => eprintln!("Wayland error: Got mode on unknown output"), None => log_print!(
logging::Level::Warning,
"Got mode on unknown output",
),
}; };
} }
@ -169,7 +177,10 @@ pub mod c {
let output = find_output_mut(&mut collection, wl_output); let output = find_output_mut(&mut collection, wl_output);
match output { match output {
Some(output) => { output.current = output.pending.clone(); } Some(output) => { output.current = output.pending.clone(); }
None => eprintln!("Wayland error: Got done on unknown output"), None => log_print!(
logging::Level::Warning,
"Got done on unknown output",
),
}; };
} }
@ -185,7 +196,10 @@ pub mod c {
.map(|o| &mut o.pending); .map(|o| &mut o.pending);
match output_state { match output_state {
Some(state) => { state.scale = factor; } Some(state) => { state.scale = factor; }
None => eprintln!("Wayland error: Got done on unknown output"), None => log_print!(
logging::Level::Warning,
"Got scale on unknown output",
),
}; };
} }
@ -258,7 +272,10 @@ pub mod c {
} }
}, },
_ => { _ => {
eprintln!("Not enough info registered on output"); log_print!(
logging::Level::Surprise,
"Not enough info received on output",
);
0 0
}, },
} }

25
src/popover.rs
View File

@ -222,14 +222,10 @@ fn translate_layout_names(layouts: &Vec<LayoutId>) -> Vec<OwnedTranslation> {
LayoutId::System { name, kind: _ } => { LayoutId::System { name, kind: _ } => {
xkb_translator.get_display_name(name) xkb_translator.get_display_name(name)
.map(|s| Status::Translated(OwnedTranslation(s))) .map(|s| Status::Translated(OwnedTranslation(s)))
.unwrap_or_else(|e| { .or_print(
eprintln!( logging::Problem::Surprise,
"No display name for xkb layout {}: {:?}", &format!("No display name for xkb layout {}", name),
name, ).unwrap_or_else(|| Status::Remaining(name.clone()))
e,
);
Status::Remaining(name.clone())
})
}, },
LayoutId::Local(name) => Status::Remaining(name.clone()), LayoutId::Local(name) => Status::Remaining(name.clone()),
}); });
@ -365,10 +361,10 @@ pub fn show(
match state { match state {
Some(v) => { Some(v) => {
v.get::<String>() v.get::<String>()
.or_else(|| { .or_print(
eprintln!("Variant is not string: {:?}", v); logging::Problem::Bug,
None &format!("Variant is not string: {:?}", v)
}) )
.map(|state| { .map(|state| {
let (_id, layout) = choices.iter() let (_id, layout) = choices.iter()
.find( .find(
@ -380,7 +376,10 @@ pub fn show(
) )
}); });
}, },
None => eprintln!("No variant selected"), None => log_print!(
logging::Level::Debug,
"No variant selected",
),
}; };
menu_inner.popdown(); menu_inner.popdown();
}); });

5
src/style.rs
View File

@ -85,7 +85,10 @@ fn get_theme_name(settings: &gtk::Settings) -> GtkTheme {
match &e { match &e {
env::VarError::NotPresent => {}, env::VarError::NotPresent => {},
// maybe TODO: forward this warning? // maybe TODO: forward this warning?
e => eprintln!("GTK_THEME variable invalid: {}", e), e => log_print!(
logging::Level::Surprise,
"GTK_THEME variable invalid: {}", e,
),
}; };
e e
}).ok(); }).ok();