Some stricter linting + resultant cleanup.

Author: bodil

vgtk/src/callback.rs

@@ -5,6 +5,7 @@ use std::rc::Rc;
 pub struct Callback<A>(pub(crate) Rc<dyn Fn(A)>);
 
 impl<A: Debug> Callback<A> {
+    /// Send a value to the callback.
     pub fn send(&self, value: A) {
         (self.0)(value)
     }
@@ -23,7 +24,7 @@ impl<A> PartialEq for Callback<A> {
 }
 
 impl<A> Debug for Callback<A> {
-    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
         write!(f, "Callback()")
     }
 }

vgtk/src/component.rs

@@ -112,7 +112,7 @@ pub(crate) enum ComponentMessage<C: Component> {
 }
 
 impl<C: Component> Debug for ComponentMessage<C> {
-    fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
         match self {
             ComponentMessage::Update(msg) => write!(
                 f,
@@ -210,12 +210,12 @@ where
         (self.sender, self.task)
     }
 
-    pub fn object(&self) -> Object {
+    pub(crate) fn object(&self) -> Object {
         self.task.ui_state.as_ref().unwrap().object().clone()
     }
 }
 
-pub struct ComponentTask<C, P>
+pub(crate) struct ComponentTask<C, P>
 where
     C: Component,
     P: Component,
@@ -247,7 +247,7 @@ where
         })
     }
 
-    pub fn process(&mut self, ctx: &mut Context) -> Poll<()> {
+    pub(crate) fn process(&mut self, ctx: &mut Context<'_>) -> Poll<()> {
         let mut render = false;
         loop {
             let next = Stream::poll_next(self.channel.as_mut(), ctx);
@@ -332,7 +332,7 @@ where
         }
     }
 
-    pub fn object(&self) -> Option<Object> {
+    pub(crate) fn object(&self) -> Option<Object> {
         self.ui_state.as_ref().map(|state| state.object().clone())
     }
 
@@ -417,7 +417,7 @@ where
 {
     type Output = ();
 
-    fn poll(self: Pin<&mut Self>, ctx: &mut Context) -> Poll<Self::Output> {
+    fn poll(self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::Output> {
         LOCAL_CONTEXT.with(|key| {
             *key.write().unwrap() = LocalContext {
                 parent_scope: self.parent_scope.as_ref().map(|scope| scope.clone().into()),

vgtk/src/ext.rs

@@ -3,6 +3,8 @@
 //! It is generally a good idea to `use vgtk::ext::*;` wherever you're using the
 //! `gtk!` macro.
 
+#![allow(missing_docs)]
+
 use gdk_pixbuf::Pixbuf;
 use gio::{Action, ActionExt, ApplicationFlags};
 use glib::{GString, IsA, Object, ObjectExt};
@@ -14,7 +16,13 @@ use gtk::{
 use colored::Colorize;
 use log::trace;
 
+/// Helper trait for `Application`.
 pub trait ApplicationHelpers: GtkApplicationExt {
+    /// Construct a new `Application` and panic if it fails.
+    ///
+    /// This is like `Application::new`, but returns an `Application` instead of
+    /// an `Option<Application>`, so you can use it as a constructor in the `gtk!`
+    /// macro.
     fn new_unwrap(application_id: Option<&str>, flags: ApplicationFlags) -> Application {
         Application::new(application_id, flags).expect("unable to create Application object")
     }
@@ -47,6 +55,7 @@ pub trait ApplicationHelpers: GtkApplicationExt {
 
 impl<A> ApplicationHelpers for A where A: GtkApplicationExt {}
 
+/// Helper trait for `ApplicationWindow`.
 pub trait ApplicationWindowHelpers: ApplicationWindowExt + GtkWindowExt + IsA<Window> {
     fn get_child_accels<P: IsA<Action>>(&self, action: &P) -> Vec<GString> {
         let app = self
@@ -99,6 +108,7 @@ pub trait ApplicationWindowHelpers: ApplicationWindowExt + GtkWindowExt + IsA<Wi
 
 impl<A> ApplicationWindowHelpers for A where A: ApplicationWindowExt + GtkWindowExt + IsA<Window> {}
 
+/// Helper trait for `Window`.
 pub trait WindowExtHelpers: GtkWindowExt {
     fn get_default_height(&self) -> i32 {
         self.get_property_default_height()
@@ -143,6 +153,7 @@ pub trait WindowExtHelpers: GtkWindowExt {
 
 impl<A> WindowExtHelpers for A where A: GtkWindowExt {}
 
+/// Helper trait for `Box`.
 pub trait BoxExtHelpers: BoxExt {
     fn get_child_center_widget(&self, _child: &Object) -> bool {
         // Always compare true, it's all taken care of in add_child().
@@ -156,6 +167,7 @@ pub trait BoxExtHelpers: BoxExt {
 
 impl<A> BoxExtHelpers for A where A: BoxExt {}
 
+/// Helper trait for `Image`.
 pub trait ImageExtHelpers: ImageExt {
     fn set_pixbuf(&self, pixbuf: Option<Pixbuf>) {
         self.set_from_pixbuf(pixbuf.as_ref());
@@ -164,6 +176,7 @@ pub trait ImageExtHelpers: ImageExt {
 
 impl<A> ImageExtHelpers for A where A: ImageExt {}
 
+/// Helper trait for `Label`.
 pub trait LabelExtHelpers: LabelExt {
     fn get_markup(&self) -> Option<GString> {
         self.get_label()

vgtk/src/lib.rs

@@ -1,5 +1,9 @@
 //! A declarative UI framework built on [GTK] and [Gtk-rs].
 //!
+//! ## Overview
+//!
+//!
+//!
 //! ## Show Me!
 //!
 //! ```rust,no_run
@@ -58,6 +62,11 @@
 //! [GTK]: https://www.gtk.org/
 //! [Gtk-rs]: https://gtk-rs.org/
 
+#![forbid(rust_2018_idioms)]
+#![deny(nonstandard_style, unsafe_code)]
+#![warn(unreachable_pub, missing_docs)]
+#![allow(clippy::needless_doctest_main)]
+
 mod callback;
 mod component;
 pub mod ext;

vgtk/src/scope.rs

@@ -101,7 +101,7 @@ impl<C: 'static + Component> From<Scope<C>> for AnyScope {
         let drop = |ptr: &mut AtomicPtr<()>| {
             let ptr = ptr.swap(std::ptr::null_mut(), Ordering::SeqCst);
             if !ptr.is_null() {
-                #[allow(clippy::cast_ptr_alignment)]
+                #[allow(unsafe_code)]
                 let scope = unsafe { Box::from_raw(ptr as *mut Scope<C>) };
                 std::mem::drop(scope)
             }
@@ -121,25 +121,11 @@ impl Drop for AnyScope {
 }
 
 impl AnyScope {
-    // pub fn try_into<C: 'static + Component>(self) -> Result<Box<Scope<C>>, Self> {
-    //     if TypeId::of::<C::Properties>() == self.type_id {
-    //         let ptr = self.ptr.swap(std::ptr::null_mut(), Ordering::SeqCst);
-    //         if ptr.is_null() {
-    //             panic!("AnyScope: can't consume dropped value")
-    //         } else {
-    //             #[allow(clippy::cast_ptr_alignment)]
-    //             Ok(unsafe { Box::from_raw(ptr as *mut Scope<C>) })
-    //         }
-    //     } else {
-    //         Err(self)
-    //     }
-    // }
-
-    pub fn try_get<C: 'static + Component>(&self) -> Option<&'static Scope<C>> {
+    pub(crate) fn try_get<C: 'static + Component>(&self) -> Option<&'static Scope<C>> {
         if TypeId::of::<C::Properties>() == self.type_id {
-            #[allow(clippy::cast_ptr_alignment)]
+            #[allow(unsafe_code)]
             unsafe {
-                (self.ptr.load(Ordering::SeqCst) as *const Scope<C>).as_ref()
+                (self.ptr.load(Ordering::Relaxed) as *const Scope<C>).as_ref()
             }
         } else {
             None

vgtk/src/vdom/component_state.rs

@@ -68,7 +68,7 @@ impl<Model: 'static + Component> ComponentState<Model> {
     }
 }
 
-pub struct SubcomponentState<Model: Component> {
+pub(crate) struct SubcomponentState<Model: Component> {
     channel: UnboundedSender<ComponentMessage<Model>>,
 }
 

vgtk/src/vdom/gtk_state.rs

@@ -12,8 +12,8 @@ use crate::component::Component;
 use crate::scope::Scope;
 use crate::vnode::{VHandler, VNode, VObject, VProperty};
 
-pub struct GtkState<Model: Component> {
-    pub object: Object,
+pub(crate) struct GtkState<Model: Component> {
+    pub(crate) object: Object,
     handlers: HashMap<(&'static str, &'static str), SignalHandlerId>,
     children: Vec<State<Model>>,
 }

vgtk/src/vdom/mod.rs

@@ -6,12 +6,12 @@ use crate::scope::Scope;
 use crate::vnode::VNode;
 
 mod component_state;
-pub use component_state::ComponentState;
+pub(crate) use component_state::ComponentState;
 
 mod gtk_state;
 use gtk_state::GtkState;
 
-pub enum State<Model: Component> {
+pub(crate) enum State<Model: Component> {
     Gtk(GtkState<Model>),
     Component(ComponentState<Model>),
 }
@@ -88,15 +88,15 @@ impl<Model: 'static + Component> State<Model> {
     }
 
     /// Get the Glib `Object` represented by this state.
-    pub fn object(&self) -> &Object {
+    pub(crate) fn object(&self) -> &Object {
         match self {
             State::Gtk(state) => &state.object,
             State::Component(state) => &state.object,
         }
     }
 
     /// Get the Gtk `Widget` represented by this state, if it has a `Widget`.
-    pub fn widget(&self) -> Option<&Widget> {
+    pub(crate) fn widget(&self) -> Option<&Widget> {
         match self {
             State::Gtk(state) => state.object.downcast_ref::<Widget>(),
             State::Component(state) => state.object.downcast_ref::<Widget>(),

vgtk/src/vnode/component.rs

@@ -45,7 +45,10 @@ impl AnyProps {
                 TypeId::of::<Props>()
             )
         }
-        unsafe { *Box::from_raw(self.data as *mut Props) }
+        #[allow(unsafe_code)]
+        unsafe {
+            *Box::from_raw(self.data as *mut Props)
+        }
     }
 }