refactor: use multi character variable name

examples/example.rs

@@ -92,8 +92,8 @@ fn main() -> Result<(), Box<dyn Error>> {
 
 fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<()> {
     loop {
-        terminal.draw(|f| {
+        terminal.draw(|frame| {
-            let area = f.size();
+            let area = frame.size();
 
             let items = Tree::new(app.items.clone())
                 .expect("all item identifiers are unique")
@@ -105,7 +105,7 @@ fn run_app<B: Backend>(terminal: &mut Terminal<B>, mut app: App) -> io::Result<(
                         .add_modifier(Modifier::BOLD),
                 )
                 .highlight_symbol(">> ");
-            f.render_stateful_widget(items, area, &mut app.state);
+            frame.render_stateful_widget(items, area, &mut app.state);
         })?;
 
         match event::read()? {

src/flatten.rs

@@ -84,7 +84,10 @@ fn get_opened_nothing_opened_is_top_level() {
     let items = get_example_tree_items();
     let opened = HashSet::new();
     let result = flatten(&opened, &items);
-    let result_text = result.iter().map(|o| o.item.identifier).collect::<Vec<_>>();
+    let result_text = result
+        .iter()
+        .map(|flattened| flattened.item.identifier)
+        .collect::<Vec<_>>();
     assert_eq!(result_text, ["a", "b", "h"]);
 }
 
@@ -95,7 +98,10 @@ fn get_opened_wrong_opened_is_only_top_level() {
     opened.insert(vec!["a"]);
     opened.insert(vec!["b", "d"]);
     let result = flatten(&opened, &items);
-    let result_text = result.iter().map(|o| o.item.identifier).collect::<Vec<_>>();
+    let result_text = result
+        .iter()
+        .map(|flattened| flattened.item.identifier)
+        .collect::<Vec<_>>();
     assert_eq!(result_text, ["a", "b", "h"]);
 }
 
@@ -105,7 +111,10 @@ fn get_opened_one_is_opened() {
     let mut opened = HashSet::new();
     opened.insert(vec!["b"]);
     let result = flatten(&opened, &items);
-    let result_text = result.iter().map(|o| o.item.identifier).collect::<Vec<_>>();
+    let result_text = result
+        .iter()
+        .map(|flattened| flattened.item.identifier)
+        .collect::<Vec<_>>();
     assert_eq!(result_text, ["a", "b", "c", "d", "g", "h"]);
 }
 
@@ -116,6 +125,9 @@ fn get_opened_all_opened() {
     opened.insert(vec!["b"]);
     opened.insert(vec!["b", "d"]);
     let result = flatten(&opened, &items);
-    let result_text = result.iter().map(|o| o.item.identifier).collect::<Vec<_>>();
+    let result_text = result
+        .iter()
+        .map(|flattened| flattened.item.identifier)
+        .collect::<Vec<_>>();
     assert_eq!(result_text, ["a", "b", "c", "d", "e", "f", "g", "h"]);
 }

src/item.rs

@@ -75,7 +75,7 @@ where
     {
         let identifiers = children
             .iter()
-            .map(|o| &o.identifier)
+            .map(|item| &item.identifier)
             .collect::<HashSet<_>>();
         if identifiers.len() != children.len() {
             return Err(std::io::Error::new(
@@ -131,7 +131,7 @@ where
         let existing = self
             .children
             .iter()
-            .map(|o| &o.identifier)
+            .map(|item| &item.identifier)
             .collect::<HashSet<_>>();
         if existing.contains(&child.identifier) {
             return Err(std::io::Error::new(
@@ -148,16 +148,16 @@ where
 #[test]
 #[should_panic = "duplicate identifiers"]
 fn tree_item_new_errors_with_duplicate_identifiers() {
-    let a = Item::new_leaf("same", "text");
+    let item = Item::new_leaf("same", "text");
-    let b = a.clone();
+    let another = item.clone();
-    Item::new("root", "Root", vec![a, b]).unwrap();
+    Item::new("root", "Root", vec![item, another]).unwrap();
 }
 
 #[test]
 #[should_panic = "identifier already exists"]
 fn tree_item_add_child_errors_with_duplicate_identifiers() {
-    let a = Item::new_leaf("same", "text");
+    let item = Item::new_leaf("same", "text");
-    let b = a.clone();
+    let another = item.clone();
-    let mut root = Item::new("root", "Root", vec![a]).unwrap();
+    let mut root = Item::new("root", "Root", vec![item]).unwrap();
-    root.add_child(b).unwrap();
+    root.add_child(another).unwrap();
 }

src/lib.rs

@@ -44,14 +44,14 @@ pub use crate::state::State as TreeState;
 /// let item = TreeItem::new_leaf("l", "leaf");
 /// let items = vec![item];
 ///
-/// terminal.draw(|f| {
+/// terminal.draw(|frame| {
-///     let area = f.size();
+///     let area = frame.size();
 ///
 ///     let tree_widget = Tree::new(items)
 ///         .expect("all item identifiers are unique")
 ///         .block(Block::bordered().title("Tree Widget"));
 ///
-///     f.render_stateful_widget(tree_widget, area, &mut state);
+///     frame.render_stateful_widget(tree_widget, area, &mut state);
 /// })?;
 /// # Ok::<(), std::io::Error>(())
 /// ```
@@ -87,7 +87,10 @@ where
     ///
     /// Errors when there are duplicate identifiers in the children.
     pub fn new(items: Vec<TreeItem<'a, Identifier>>) -> std::io::Result<Self> {
-        let identifiers = items.iter().map(|o| &o.identifier).collect::<HashSet<_>>();
+        let identifiers = items
+            .iter()
+            .map(|item| &item.identifier)
+            .collect::<HashSet<_>>();
         if identifiers.len() != items.len() {
             return Err(std::io::Error::new(
                 std::io::ErrorKind::AlreadyExists,
@@ -161,9 +164,9 @@ where
 #[test]
 #[should_panic = "duplicate identifiers"]
 fn tree_new_errors_with_duplicate_identifiers() {
-    let a = TreeItem::new_leaf("same", "text");
+    let item = TreeItem::new_leaf("same", "text");
-    let b = a.clone();
+    let another = item.clone();
-    Tree::new(vec![a, b]).unwrap();
+    Tree::new(vec![item, another]).unwrap();
 }
 
 impl<'a, Identifier> StatefulWidget for Tree<'a, Identifier>
@@ -177,9 +180,9 @@ where
         buf.set_style(area, self.style);
 
         // Get the inner area inside a possible block, otherwise use the full area
-        let area = self.block.map_or(area, |b| {
+        let area = self.block.map_or(area, |block| {
-            let inner_area = b.inner(area);
+            let inner_area = block.inner(area);
-            b.render(area, buf);
+            block.render(area, buf);
             inner_area
         });
 
@@ -198,7 +201,7 @@ where
         } else {
             visible
                 .iter()
-                .position(|o| o.identifier == state.selected)
+                .position(|flattened| flattened.identifier == state.selected)
                 .unwrap_or(0)
         };
 

src/state.rs

@@ -112,7 +112,7 @@ where
     pub fn select_first(&mut self, items: &[Item<Identifier>]) -> bool {
         let identifier = items
             .first()
-            .map(|o| vec![o.identifier.clone()])
+            .map(|item| vec![item.identifier.clone()])
             .unwrap_or_default();
         self.select(identifier)
     }
@@ -124,7 +124,7 @@ where
         let visible = self.flatten(items);
         let new_identifier = visible
             .last()
-            .map(|o| o.identifier.clone())
+            .map(|flattened| flattened.identifier.clone())
             .unwrap_or_default();
         self.select(new_identifier)
     }
@@ -139,7 +139,7 @@ where
         let new_index = new_index.min(visible.len().saturating_sub(1));
         let new_identifier = visible
             .get(new_index)
-            .map(|o| o.identifier.clone())
+            .map(|flattened| flattened.identifier.clone())
             .unwrap_or_default();
         self.select(new_identifier)
     }
@@ -163,7 +163,11 @@ where
     ///
     /// For more examples take a look into the source code of [`key_up`](State::key_up) or [`key_down`](State::key_down).
     /// They are implemented with this method.
-    pub fn select_visible_relative<F>(&mut self, items: &[Item<Identifier>], f: F) -> bool
+    pub fn select_visible_relative<F>(
+        &mut self,
+        items: &[Item<Identifier>],
+        change_function: F,
+    ) -> bool
     where
         F: FnOnce(Option<usize>) -> usize,
     {
@@ -171,11 +175,11 @@ where
         let current_identifier = self.selected();
         let current_index = visible
             .iter()
-            .position(|o| o.identifier == current_identifier);
+            .position(|flattened| flattened.identifier == current_identifier);
-        let new_index = f(current_index).min(visible.len().saturating_sub(1));
+        let new_index = change_function(current_index).min(visible.len().saturating_sub(1));
         let new_identifier = visible
             .get(new_index)
-            .map(|o| o.identifier.clone())
+            .map(|flattened| flattened.identifier.clone())
             .unwrap_or_default();
         self.select(new_identifier)
     }