Update rustfmt config

Now uses nightly rustfmt.

cursive-core/src/cursive.rs

@@ -309,14 +309,18 @@ impl Cursive {
     /// let mut siv = Cursive::new();
     ///
     /// siv.menubar()
-    ///    .add_subtree("File",
+    ///     .add_subtree(
+    ///         "File",
     ///         MenuTree::new()
     ///             .leaf("New", |s| s.add_layer(Dialog::info("New file!")))
-    ///             .subtree("Recent", MenuTree::new().with(|tree| {
+    ///             .subtree(
+    ///                 "Recent",
+    ///                 MenuTree::new().with(|tree| {
     ///                     for i in 1..100 {
     ///                         tree.add_leaf(format!("Item {}", i), |_| ())
     ///                     }
-    ///             }))
+    ///                 }),
+    ///             )
     ///             .delimiter()
     ///             .with(|tree| {
     ///                 for i in 1..10 {
@@ -324,19 +328,25 @@ impl Cursive {
     ///                 }
     ///             })
     ///             .delimiter()
-    ///             .leaf("Quit", |s| s.quit()))
+    ///             .leaf("Quit", |s| s.quit()),
-    ///    .add_subtree("Help",
+    ///     )
+    ///     .add_subtree(
+    ///         "Help",
     ///         MenuTree::new()
-    ///             .subtree("Help",
+    ///             .subtree(
+    ///                 "Help",
     ///                 MenuTree::new()
     ///                     .leaf("General", |s| {
     ///                         s.add_layer(Dialog::info("Help message!"))
     ///                     })
     ///                     .leaf("Online", |s| {
     ///                         s.add_layer(Dialog::info("Online help?"))
-    ///                          }))
+    ///                     }),
-    ///             .leaf("About",
+    ///             )
-    ///                   |s| s.add_layer(Dialog::info("Cursive v0.0.0"))));
+    ///             .leaf("About", |s| {
+    ///                 s.add_layer(Dialog::info("Cursive v0.0.0"))
+    ///             }),
+    ///     );
     ///
     /// siv.add_global_callback(event::Key::Esc, |s| s.select_menubar());
     /// ```
@@ -503,8 +513,7 @@ impl Cursive {
     /// # use cursive_core::traits::*;
     /// let mut siv = Cursive::new();
     ///
-    /// siv.add_layer(views::TextView::new("Text #1")
+    /// siv.add_layer(views::TextView::new("Text #1").with_name("text"));
-    ///                               .with_name("text"));
     ///
     /// siv.add_global_callback('p', |s| {
     ///     s.call_on_name("text", |view: &mut views::TextView| {
@@ -754,7 +763,7 @@ impl Cursive {
     /// # Examples
     ///
     /// ```rust
-    /// use cursive_core::{Cursive, views};
+    /// use cursive_core::{views, Cursive};
     /// let mut siv = Cursive::new();
     ///
     /// siv.add_layer(views::TextView::new("Hello world!"));

cursive-core/src/event.rs

@@ -82,7 +82,10 @@ impl EventTrigger {
     ///
     /// let event = Event::CtrlChar('c');
     /// let trigger: EventTrigger = event.clone().into();
-    /// assert!(trigger.has_tag(&event), "Trigger does not recognize its own tag.");
+    /// assert!(
+    ///     trigger.has_tag(&event),
+    ///     "Trigger does not recognize its own tag."
+    /// );
     /// ```
     pub fn has_tag<T: PartialEq + 'static>(&self, tag: &T) -> bool {
         (*self.tag)
@@ -116,13 +119,7 @@ impl EventTrigger {
 
     /// Returns an `EventTrigger` that only accepts mouse events.
     pub fn mouse() -> Self {
-        Self::from_fn_and_tag(
+        Self::from_fn_and_tag(|e| matches!(e, Event::Mouse { .. }), "mouse")
-            |e| {
-                matches!(e,
-                Event::Mouse { .. })
-            },
-            "mouse",
-        )
     }
 
     /// Returns an `EventTrigger` that accepts any event.
@@ -459,10 +456,10 @@ impl MouseEvent {
     /// It means you should be able to grab a scroll bar, and move the mouse
     /// away from the view, without actually changing the focus.
     pub fn grabs_focus(self) -> bool {
-        matches!(self,
+        matches!(
-            MouseEvent::Press(_)
+            self,
-            | MouseEvent::WheelUp
+            MouseEvent::Press(_) | MouseEvent::WheelUp | MouseEvent::WheelDown
-            | MouseEvent::WheelDown)
+        )
     }
 }
 

cursive-core/src/utils/immutify.rs

@@ -57,13 +57,16 @@ pub fn immutify<F: FnMut(&mut Cursive)>(
 /// # let mut siv = Cursive::new();
 /// let mut i = 0;
 /// // `Cursive::add_global_callback` takes a `Fn(&mut Cursive)`
-/// siv.add_global_callback('q', immut1!(move |s: &mut Cursive| {
+/// siv.add_global_callback(
+///     'q',
+///     immut1!(move |s: &mut Cursive| {
 ///         // But here we mutate the environment! Crazy!
 ///         i += 1;
 ///         if i == 5 {
 ///             s.quit();
 ///         }
-/// }));
+///     }),
+/// );
 /// # }
 /// ```
 #[macro_export]

cursive-core/src/view/nameable.rs

@@ -20,11 +20,7 @@ pub trait Nameable: View + Sized {
     /// use cursive_core::view::Nameable;
     ///
     /// let mut siv = Cursive::new();
-    /// siv.add_layer(
+    /// siv.add_layer(TextView::new("foo").with_name("text").fixed_width(10));
-    ///     TextView::new("foo")
-    ///         .with_name("text")
-    ///         .fixed_width(10)
-    /// );
     ///
     /// // You could call this from an event callback
     /// siv.call_on_name("text", |view: &mut TextView| {
@@ -40,7 +36,6 @@ pub trait Nameable: View + Sized {
     ///
     /// [`fixed_width`]: crate::view::Resizable::fixed_width
     /// [`ResizedView`]: crate::views::ResizedView
-    ///
     fn with_name<S: Into<String>>(self, name: S) -> NamedView<Self> {
         NamedView::new(name, self)
     }

cursive-core/src/view/scroll/mod.rs

@@ -50,9 +50,9 @@ impl Default for ScrollStrategy {
 /// Example:
 ///
 /// ```
-/// use cursive_core::{Printer, Vec2, Rect};
 /// use cursive_core::event::{Event, EventResult};
-/// use cursive_core::view::{View, scroll};
+/// use cursive_core::view::{scroll, View};
+/// use cursive_core::{Printer, Rect, Vec2};
 ///
 /// struct MyView {
 ///     core: scroll::Core,
@@ -73,7 +73,12 @@ impl Default for ScrollStrategy {
 /// impl View for MyView {
 /// # fn draw(&self, printer: &Printer) {}
 ///     fn on_event(&mut self, event: Event) -> EventResult {
-///         scroll::on_event(self, event, Self::inner_on_event, Self::inner_important_area)
+///         scroll::on_event(
+///             self,
+///             event,
+///             Self::inner_on_event,
+///             Self::inner_important_area,
+///         )
 ///     }
 /// }
 /// ```

cursive-core/src/view/scroll/raw.rs

@@ -2,7 +2,6 @@
 //!
 //! Most functions take a generic `Model` class, and various closures to get
 //! the required things from this model.
-//!
 use crate::{
     event::{Event, EventResult, Key, MouseButton, MouseEvent},
     rect::Rect,

cursive-core/src/views/canvas.rs

@@ -16,8 +16,8 @@ type CallOnAny<T> = Box<dyn for<'a> FnMut(&mut T, &Selector, AnyCb<'a>)>;
 /// # Examples
 ///
 /// ```rust
-/// use cursive_core::views::{Canvas, Dialog};
 /// use cursive_core::event::{Event, EventResult, Key};
+/// use cursive_core::views::{Canvas, Dialog};
 /// use unicode_width::UnicodeWidthStr; // To get the width of some text.
 ///
 /// // Build a canvas around a string.
@@ -27,8 +27,7 @@ type CallOnAny<T> = Box<dyn for<'a> FnMut(&mut T, &Selector, AnyCb<'a>)>;
 ///         // Simply print our string
 ///         printer.print((0, 0), text);
 ///     })
-///                     .with_on_event(|text: &mut String, event| {
+///     .with_on_event(|text: &mut String, event| match event {
-///                         match event {
 ///         Event::Char(c) => {
 ///             text.push(c);
 ///             EventResult::Consumed(None)
@@ -38,13 +37,10 @@ type CallOnAny<T> = Box<dyn for<'a> FnMut(&mut T, &Selector, AnyCb<'a>)>;
 ///             EventResult::with_cb(move |s| {
 ///                 s.add_layer(Dialog::info(&text));
 ///             })
-///                             },
-///                             _ => EventResult::Ignored,
 ///         }
+///         _ => EventResult::Ignored,
 ///     })
-///                     .with_required_size(|text, _constraints| {
+///     .with_required_size(|text, _constraints| (text.width(), 1).into());
-///                         (text.width(), 1).into()
-///                     });
 /// ```
 pub struct Canvas<T> {
     state: T,

cursive-core/src/views/checkbox.rs

@@ -13,8 +13,8 @@ use std::rc::Rc;
 /// # Examples
 ///
 /// ```
-/// use cursive_core::views::Checkbox;
 /// use cursive_core::traits::Identifiable;
+/// use cursive_core::views::Checkbox;
 ///
 /// let checkbox = Checkbox::new().checked().with_name("check");
 /// ```

cursive-core/src/views/dialog.rs

@@ -45,8 +45,8 @@ impl ChildButton {
 ///
 /// ```
 /// # use cursive_core::views::{Dialog,TextView};
-/// let dialog = Dialog::around(TextView::new("Hello!"))
+/// let dialog =
-///                     .button("Ok", |s| s.quit());
+///     Dialog::around(TextView::new("Hello!")).button("Ok", |s| s.quit());
 /// ```
 pub struct Dialog {
     // Possibly empty title.
@@ -125,10 +125,8 @@ impl Dialog {
     /// ```
     /// use cursive_core::views::{Dialog, TextView};
     /// let dialog = Dialog::around(TextView::new("Hello!"));
-    /// let text_view: &TextView = dialog
+    /// let text_view: &TextView =
-    ///     .get_content()
+    ///     dialog.get_content().downcast_ref::<TextView>().unwrap();
-    ///     .downcast_ref::<TextView>()
-    ///     .unwrap();
     /// assert_eq!(text_view.get_content().source(), "Hello!");
     /// ```
     pub fn get_content(&self) -> &dyn View {
@@ -146,8 +144,8 @@ impl Dialog {
     /// # Examples
     ///
     /// ```
-    /// use cursive_core::views::{Dialog, TextView};
     /// use cursive_core::view::View;
+    /// use cursive_core::views::{Dialog, TextView};
     ///
     /// let dialog = Dialog::around(TextView::new("abc"));
     ///
@@ -176,8 +174,7 @@ impl Dialog {
     /// ```
     /// use cursive_core::views::Dialog;
     ///
-    /// let dialog = Dialog::text("Hello!")
+    /// let dialog = Dialog::text("Hello!").button("Quit", |s| s.quit());
-    ///             .button("Quit", |s| s.quit());
     /// ```
     pub fn text<S: Into<StyledString>>(text: S) -> Self {
         Self::around(TextView::new(text))
@@ -267,8 +264,7 @@ impl Dialog {
     /// ```
     /// use cursive_core::views::Dialog;
     ///
-    /// let dialog = Dialog::text("Hello!")
+    /// let dialog = Dialog::text("Hello!").dismiss_button("Close");
-    ///         .dismiss_button("Close");
     /// ```
     pub fn dismiss_button<S: Into<String>>(self, label: S) -> Self {
         self.button(label, |s| {
@@ -285,8 +281,7 @@ impl Dialog {
     /// ```
     /// use cursive_core::views::Dialog;
     ///
-    /// let dialog = Dialog::info("Some info")
+    /// let dialog = Dialog::info("Some info").title("Read me!");
-    ///         .title("Read me!");
     /// ```
     pub fn title<S: Into<String>>(self, label: S) -> Self {
         self.with(|s| s.set_title(label))

cursive-core/src/views/edit_view.rs

@@ -50,10 +50,11 @@ pub type OnSubmit = dyn Fn(&mut Cursive, &str);
 ///                 .fixed_width(20),
 ///         )
 ///         .button("Ok", |s| {
-///             let name = s.call_on_name(
+///             let name = s
-///                 "name",
+///                 .call_on_name("name", |view: &mut EditView| {
-///                 |view: &mut EditView| view.get_content(),
+///                     view.get_content()
-///             ).unwrap();
+///                 })
+///                 .unwrap();
 ///             show_popup(s, &name);
 ///         }),
 /// );
@@ -64,8 +65,10 @@ pub type OnSubmit = dyn Fn(&mut Cursive, &str);
 ///     } else {
 ///         let content = format!("Hello {}!", name);
 ///         s.pop_layer();
-///         s.add_layer(Dialog::around(TextView::new(content))
+///         s.add_layer(
-///             .button("Quit", |s| s.quit()));
+///             Dialog::around(TextView::new(content))
+///                 .button("Quit", |s| s.quit()),
+///         );
 ///     }
 /// }
 /// ```
@@ -253,13 +256,12 @@ impl EditView {
     /// # Examples
     ///
     /// ```
-    /// use cursive_core::views::{TextContent, TextView, EditView};
+    /// use cursive_core::views::{EditView, TextContent, TextView};
     /// // Keep the length of the text in a separate view.
     /// let mut content = TextContent::new("0");
     /// let text_view = TextView::new_with_content(content.clone());
     ///
-    /// let on_edit = EditView::new()
+    /// let on_edit = EditView::new().on_edit(move |_s, text, _cursor| {
-    ///             .on_edit(move |_s, text, _cursor| {
     ///     content.set_content(format!("{}", text.len()));
     /// });
     /// ```
@@ -329,8 +331,7 @@ impl EditView {
     /// ```
     /// use cursive_core::views::{Dialog, EditView};
     ///
-    /// let edit_view = EditView::new()
+    /// let edit_view = EditView::new().on_submit(|s, text| {
-    ///     .on_submit(|s, text| {
     ///     s.add_layer(Dialog::info(text));
     /// });
     /// ```

cursive-core/src/views/fixed_layout.rs

@@ -14,7 +14,7 @@ use crate::{
 ///
 /// ```rust
 /// use cursive_core::{
-///     views::{FixedLayout, TextView, Button},
+///     views::{Button, FixedLayout, TextView},
 ///     Rect,
 /// };
 ///
@@ -23,7 +23,10 @@ use crate::{
 ///     .child(Rect::from_size((14, 0), (1, 1)), TextView::new(r"\"))
 ///     .child(Rect::from_size((0, 2), (1, 1)), TextView::new(r"\"))
 ///     .child(Rect::from_size((14, 2), (1, 1)), TextView::new("/"))
-///     .child(Rect::from_size((3,1), (11,1)), Button::new("Clickme", |s| s.quit()));
+///     .child(
+///         Rect::from_size((3, 1), (11, 1)),
+///         Button::new("Clickme", |s| s.quit()),
+///     );
 /// ```
 pub struct FixedLayout {
     children: Vec<Child>,

cursive-core/src/views/linear_layout.rs

@@ -15,8 +15,8 @@ use std::ops::Deref;
 /// # Examples
 ///
 /// ```
-/// use cursive_core::views::{Button, LinearLayout, TextView, TextArea};
 /// use cursive_core::traits::Boxable;
+/// use cursive_core::views::{Button, LinearLayout, TextArea, TextView};
 ///
 /// let linear_layout = LinearLayout::horizontal()
 ///     .child(TextView::new("Top of the page"))

cursive-core/src/views/on_layout_view.rs

@@ -12,7 +12,10 @@ impl<V> OnLayoutView<V> {
     /// Will run the given closure for layout _instead_ of the one from `view`.
     ///
     /// ```rust
-    /// use cursive_core::{View, views::{TextView, OnLayoutView}};
+    /// use cursive_core::{
+    ///     views::{OnLayoutView, TextView},
+    ///     View,
+    /// };
     ///
     /// let view = TextView::new("foo");
     ///

cursive-core/src/views/padded_view.rs

@@ -15,10 +15,9 @@ use crate::Vec2;
 /// ```rust
 /// # use cursive_core::views::{TextView, PaddedView};
 /// // Adds 2 columns of padding to the left and to the right.
-/// let view = PaddedView::lrtb(
+///
-///     2,2,0,0, // Left, Right, Top, Bottom
+/// // lrtb = Left, Right, Top, Bottom
-///     TextView::new("Padded text")
+/// let view = PaddedView::lrtb(2, 2, 0, 0, TextView::new("Padded text"));
-/// );
 /// ```
 pub struct PaddedView<V> {
     view: V,

cursive-core/src/views/progress_bar.rs

@@ -24,8 +24,7 @@ use std::thread;
 ///
 /// ```
 /// # use cursive_core::views::ProgressBar;
-/// let bar = ProgressBar::new()
+/// let bar = ProgressBar::new().with_task(|counter| {
-///                       .with_task(|counter| {
 ///     // This closure is called in parallel.
 ///     for _ in 0..100 {
 ///         // Here we can communicate some

cursive-core/src/views/radio.rs

@@ -120,7 +120,6 @@ impl RadioGroup<String> {
 ///
 /// `RadioButton`s are not created directly, but through
 /// [`RadioGroup::button`].
-///
 pub struct RadioButton<T> {
     state: Rc<RefCell<SharedState<T>>>,
     id: usize,

cursive-core/src/views/select_view.rs

@@ -36,13 +36,13 @@ use std::rc::Rc;
 /// time_select.set_on_submit(|s, time| {
 ///     s.pop_layer();
 ///     let text = format!("You will wait for {} minutes...", time);
-///     s.add_layer(Dialog::around(TextView::new(text))
+///     s.add_layer(
-///                     .button("Quit", |s| s.quit()));
+///         Dialog::around(TextView::new(text)).button("Quit", |s| s.quit()),
+///     );
 /// });
 ///
 /// let mut siv = Cursive::new();
-/// siv.add_layer(Dialog::around(time_select)
+/// siv.add_layer(Dialog::around(time_select).title("How long is your wait?"));
-///                      .title("How long is your wait?"));
 /// ```
 pub struct SelectView<T = String> {
     // The core of the view: we store a list of items
@@ -149,7 +149,7 @@ impl<T: 'static> SelectView<T> {
     ///
     /// ```
     /// use cursive_core::traits::Identifiable;
-    /// use cursive_core::views::{TextView, SelectView};
+    /// use cursive_core::views::{SelectView, TextView};
     ///
     /// let text_view = TextView::new("").with_name("text");
     ///
@@ -166,7 +166,8 @@ impl<T: 'static> SelectView<T> {
     ///         // Update the textview with the currently selected item.
     ///         s.call_on_name("text", |v: &mut TextView| {
     ///             v.set_content(content);
-    ///         }).unwrap();
+    ///         })
+    ///         .unwrap();
     ///     });
     /// ```
     pub fn on_select<F>(self, cb: F) -> Self
@@ -298,10 +299,9 @@ impl<T: 'static> SelectView<T> {
     /// Gets an item at given idx or None.
     ///
     /// ```
-    /// use cursive_core::Cursive;
     /// use cursive_core::views::{SelectView, TextView};
-    /// let select = SelectView::new()
+    /// use cursive_core::Cursive;
-    ///     .item("Short", 1);
+    /// let select = SelectView::new().item("Short", 1);
     /// assert_eq!(select.get_item(0), Some(("Short", &1)));
     /// ```
     pub fn get_item(&self, i: usize) -> Option<(&str, &T)> {
@@ -430,9 +430,7 @@ impl<T: 'static> SelectView<T> {
     ///
     /// // Create a SelectView with 100 items
     /// let select_view = SelectView::new()
-    ///     .with_all((1u8..100).into_iter().map(|i| {
+    ///     .with_all((1u8..100).into_iter().map(|i| (format!("Item {}", i), i)));
-    ///         (format!("Item {}", i), i)
-    ///     }));
     /// ```
     pub fn with_all<S, I>(self, iter: I) -> Self
     where
@@ -845,8 +843,7 @@ impl SelectView<String> {
     ///
     /// let text = "..."; // Maybe read some config file
     ///
-    /// let select_view = SelectView::new()
+    /// let select_view = SelectView::new().with_all_str(text.lines());
-    ///     .with_all_str(text.lines());
     /// ```
     pub fn with_all_str<S, I>(self, iter: I) -> Self
     where

cursive-core/src/views/slider_view.rs

@@ -17,8 +17,10 @@ use std::rc::Rc;
 /// use cursive_core::views::{Dialog, SliderView};
 ///
 /// let slider_view = SliderView::horizontal(10)
-///     .on_change(|s, n| if n == 5 {
+///     .on_change(|s, n| {
+///         if n == 5 {
 ///             s.add_layer(Dialog::info("5! Pick 5!"));
+///         }
 ///     })
 ///     .on_enter(|s, n| match n {
 ///         5 => s.add_layer(Dialog::info("You did it!")),

cursive-core/src/views/text_area.rs

@@ -21,7 +21,7 @@ use unicode_width::UnicodeWidthStr;
 /// # Examples
 ///
 /// ```
-/// use cursive_core::traits::{Resizable, Identifiable};
+/// use cursive_core::traits::{Identifiable, Resizable};
 /// use cursive_core::views::TextArea;
 ///
 /// let text_area = TextArea::new()

cursive-core/src/xy.rs

@@ -88,7 +88,6 @@ impl<T> XY<T> {
     /// let cond = XY::new(true, false);
     ///
     /// assert_eq!(xy.map_if(cond, |v| v * 3), XY::new(3, 2));
-    ///
     /// ```
     pub fn map_if<F>(self, condition: XY<bool>, f: F) -> Self
     where
@@ -305,8 +304,8 @@ impl<T> XY<T> {
     /// let d = XY::new(vec![1], vec![2, 3, 4]);
     /// let e = XY::new('a', 'b');
     ///
-    /// let xy: XY<Option<char>> = XY::zip5(a, b, c, d, e)
+    /// let xy: XY<Option<char>> =
-    ///     .map(|(a, b, c, d, e)| {
+    ///     XY::zip5(a, b, c, d, e).map(|(a, b, c, d, e)| {
     ///         if b && d.contains(&a) {
     ///             Some(e)
     ///         } else {

rustfmt.toml

@@ -1,3 +1,9 @@
-max_width = 79
+edition = "2018"
-reorder_imports = true
 fn_args_layout = "Tall"
+format_code_in_doc_comments = true
+max_width = 79
+merge_derives = true
+reorder_imports = true
+reorder_modules = true
+use_field_init_shorthand = true
+use_try_shorthand = true