Provide a basic default implementation of History

examples/history.rs

@@ -1,13 +1,13 @@
-use dialoguer::{theme::ColorfulTheme, History, Input};
-use std::{collections::VecDeque, process};
+use dialoguer::{theme::ColorfulTheme, BasicHistory, Input};
+use std::process;
 
 fn main() {
     println!("Use 'exit' to quit the prompt");
-    println!("In this example, history is limited to 4 entries");
+    println!("In this example, history is limited to 8 entries and contains no duplicates");
     println!("Use the Up/Down arrows to scroll through history");
     println!();
 
-    let mut history = MyHistory::default();
+    let mut history = BasicHistory::new().max_entries(8).no_duplicates(true);
 
     loop {
         if let Ok(cmd) = Input::<String>::with_theme(&ColorfulTheme::default())
@@ -22,30 +22,3 @@ fn main() {
         }
     }
 }
-
-struct MyHistory {
-    max: usize,
-    history: VecDeque<String>,
-}
-
-impl Default for MyHistory {
-    fn default() -> Self {
-        MyHistory {
-            max: 4,
-            history: VecDeque::new(),
-        }
-    }
-}
-
-impl<T: ToString> History<T> for MyHistory {
-    fn read(&self, pos: usize) -> Option<String> {
-        self.history.get(pos).cloned()
-    }
-
-    fn write(&mut self, val: &T) {
-        if self.history.len() == self.max {
-            self.history.pop_back();
-        }
-        self.history.push_front(val.to_string());
-    }
-}

examples/history_custom.rs

@@ -0,0 +1,51 @@
+use dialoguer::{theme::ColorfulTheme, History, Input};
+use std::{collections::VecDeque, process};
+
+fn main() {
+    println!("Use 'exit' to quit the prompt");
+    println!("In this example, history is limited to 4 entries");
+    println!("Use the Up/Down arrows to scroll through history");
+    println!();
+
+    let mut history = MyHistory::default();
+
+    loop {
+        if let Ok(cmd) = Input::<String>::with_theme(&ColorfulTheme::default())
+            .with_prompt("dialoguer")
+            .history_with(&mut history)
+            .interact_text()
+        {
+            if cmd == "exit" {
+                process::exit(0);
+            }
+            println!("Entered {}", cmd);
+        }
+    }
+}
+
+struct MyHistory {
+    max: usize,
+    history: VecDeque<String>,
+}
+
+impl Default for MyHistory {
+    fn default() -> Self {
+        MyHistory {
+            max: 4,
+            history: VecDeque::new(),
+        }
+    }
+}
+
+impl<T: ToString> History<T> for MyHistory {
+    fn read(&self, pos: usize) -> Option<String> {
+        self.history.get(pos).cloned()
+    }
+
+    fn write(&mut self, val: &T) {
+        if self.history.len() == self.max {
+            self.history.pop_back();
+        }
+        self.history.push_front(val.to_string());
+    }
+}

src/history.rs

@@ -1,3 +1,5 @@
+use std::collections::VecDeque;
+
 /// Trait for history handling.
 pub trait History<T> {
     /// This is called with the current position that should
@@ -13,3 +15,72 @@ pub trait History<T> {
     /// is implemented as a FIFO queue.
     fn write(&mut self, val: &T);
 }
+
+pub struct BasicHistory {
+    max_entries: Option<usize>,
+    deque: VecDeque<String>,
+    no_duplicates: bool,
+}
+
+impl BasicHistory {
+    /// Creates a new basic history value which has no limit on the number of
+    /// entries and allows for duplicates.
+    /// 
+    /// # Example
+    /// 
+    /// A history with at most 8 entries and no duplicates:
+    /// 
+    /// ```rs
+    /// let mut history = BasicHistory::new().max_entries(8).no_duplicates(true);
+    /// ```
+    pub fn new() -> Self {
+        Self {
+            max_entries: None,
+            deque: VecDeque::new(),
+            no_duplicates: false,
+        }
+    }
+
+    /// Limit the number of entries stored in the history.
+    pub fn max_entries(self, max_entries: usize) -> Self {
+        Self {
+            max_entries: Some(max_entries),
+            ..self
+        }
+    }
+
+    /// Prevent duplicates in the history. This means that any previous entries
+    /// that are equal to a new entry are removed before the new entry is added.
+    pub fn no_duplicates(self, no_duplicates: bool) -> Self {
+        Self {
+            no_duplicates,
+            ..self
+        }
+    }
+}
+
+impl<T: ToString> History<T> for BasicHistory {
+    fn read(&self, pos: usize) -> Option<String> {
+        self.deque.get(pos).cloned()
+    }
+
+    fn write(&mut self, val: &T) {
+        let val = val.to_string();
+
+        if self.no_duplicates {
+            self.deque.retain(|v| v != &val);
+        }
+
+        self.deque.push_front(val);
+
+        if let Some(max_entries) = self.max_entries {
+            self.deque.truncate(max_entries);
+        }
+    }
+}
+
+impl Default for BasicHistory {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/lib.rs

@@ -37,7 +37,7 @@ pub use console;
 #[cfg(feature = "editor")]
 pub use edit::Editor;
 #[cfg(feature = "history")]
-pub use history::History;
+pub use history::{History, BasicHistory};
 use paging::Paging;
 pub use prompts::{
     confirm::Confirm, input::Input, multi_select::MultiSelect, select::Select, sort::Sort,

src/prompts/input.rs

@@ -13,6 +13,7 @@ use console::{Key, Term};
 
 type ValidatorCallback<'a, T> = Box<dyn FnMut(&T) -> Option<String> + 'a>;
 
+
 /// Renders an input prompt.
 ///
 /// ## Example usage