Struct InputHistory 

pub struct InputHistory { /* private fields */ }

Input history for prompt navigation (like bash/readline)

This struct maintains a history of previously entered values and allows navigating through them with up/down arrows.

Navigation Behavior

• History items are stored in a Vec (oldest to newest)
• position = None means “at current input” (not navigating)
• position = Some(i) means “viewing history item i”
• When you first press up, current input is saved to temp_input
• When you navigate past the end (down from last item), temp_input is restored

Future Persistence

To add persistence later:

• Implement serde::Serialize and serde::Deserialize
• Add methods: save_to_file(), load_from_file()
• Store in config directory, separate files per history type

Implementations

impl InputHistory

pub const DEFAULT_MAX_SIZE: usize = 100

Default maximum history size

pub fn new() -> Self

Create a new history with default capacity (100 items)

pub fn with_capacity(max_size: usize) -> Self

Create a new history with specified capacity

Arguments

• max_size - Maximum number of history items to keep (must be > 0)

Panics

Panics if max_size is 0

pub fn push(&mut self, item: String)

Add an item to history (most recent)

This method:

• Skips empty strings
• Skips exact duplicates of the most recent item
• Enforces max_size by removing oldest items
• Resets navigation state

Example

let mut history = InputHistory::new();
history.push("first".to_string());
history.push("second".to_string());
history.push("second".to_string()); // Skipped (duplicate)
assert_eq!(history.len(), 2);

pub fn navigate_prev(&mut self, current_input: &str) -> Option<String>

Navigate to previous item in history (up arrow)

On first call, saves current_input to temporary storage and returns the most recent history item. On subsequent calls, moves backwards through history.

Arguments

• current_input - The current prompt input (saved on first navigation)

Returns

• Some(String) - The previous history item
• None - No more items (already at oldest)

Example

let mut history = InputHistory::new();
history.push("first".to_string());
history.push("second".to_string());

let prev = history.navigate_prev("typing...");
assert_eq!(prev, Some("second".to_string()));

let prev2 = history.navigate_prev("typing...");
assert_eq!(prev2, Some("first".to_string()));

let prev3 = history.navigate_prev("typing...");
assert_eq!(prev3, None); // Already at oldest

pub fn navigate_next(&mut self) -> Option<String>

Navigate to next item in history (down arrow)

Moves forward through history (towards more recent items). When navigating past the most recent item, returns the original input that was saved when navigation started.

Returns

• Some(String) - The next history item, or original input if past end
• None - Not currently navigating

Example

let mut history = InputHistory::new();
history.push("first".to_string());
history.push("second".to_string());

// Start navigating backwards
history.navigate_prev("typing...");
history.navigate_prev("typing...");

// Navigate forwards
let next = history.navigate_next();
assert_eq!(next, Some("second".to_string()));

// Navigate past the end returns to original input
let next2 = history.navigate_next();
assert_eq!(next2, Some("typing...".to_string()));

pub fn reset_navigation(&mut self)

Reset navigation state

Call this when:

• User confirms the prompt (Enter)
• User cancels the prompt (Escape)
• User starts typing (optional, depends on desired behavior)

This clears the temporary input storage and resets the position.

pub fn last(&self) -> Option<&str>

Get the most recent item without navigating

Useful for pre-filling prompts with the last search term.

Example

let mut history = InputHistory::new();
history.push("last search".to_string());
assert_eq!(history.last(), Some("last search"));

pub fn init_at_last(&mut self)

Initialize navigation at the last history item

Call this when pre-filling a prompt with the last history item. This sets up the navigation state so that pressing Up will go to the second-to-last item, not the last item again.

Example

let mut history = InputHistory::new();
history.push("first".to_string());
history.push("second".to_string());
history.push("third".to_string());

// Pre-fill prompt with "third"
history.init_at_last();

// Now Up goes to "second", not "third"
let prev = history.navigate_prev("third");
assert_eq!(prev, Some("second".to_string()));

pub fn is_empty(&self) -> bool

Check if history is empty

pub fn len(&self) -> usize

Get number of items in history

pub fn clear(&mut self)

Clear all history

Removes all items and resets navigation state.

pub fn items(&self) -> &[String]

Get a reference to the history items (oldest to newest)

Useful for session persistence.

pub fn from_items(items: Vec<String>) -> Self

Create a history from existing items

Useful for session restoration.

pub fn save_to_file(&self, path: &Path) -> Result<()>

Save history to a file

pub fn load_from_file(path: &Path) -> Result<Self>

Load history from a file

Trait Implementations

impl Clone for InputHistory

fn clone(&self) -> InputHistory

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InputHistory

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for InputHistory

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for InputHistory

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for InputHistory

fn eq(&self, other: &InputHistory) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for InputHistory

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for InputHistory