Enum EolAction 

pub enum EolAction {
    Trash,
    Delete,
}

Represents the action to take on Gmail messages that meet end-of-life criteria.

This enum defines the two possible actions for handling messages when they reach the end of their lifecycle based on configured retention rules.

Variants

• Trash - Move messages to Gmail’s trash folder (default, reversible)
• Delete - Permanently delete messages (irreversible)

Default Behavior

The default action is Trash, which provides a safety net by allowing message recovery from the trash folder.

Examples

use cull_gmail::EolAction;

// Using the default (Trash)
let safe_action = EolAction::default();
assert_eq!(safe_action, EolAction::Trash);

// Comparing actions
let delete = EolAction::Delete;
let trash = EolAction::Trash;
assert_ne!(delete, trash);

// Converting to string for logging/display
println!("Action: {}", delete); // Prints: "delete"

Variants

Trash

Move the message to Gmail’s trash folder.

This is the default and safer option as it allows message recovery. Messages in the trash are automatically deleted by Gmail after 30 days.

Safety

This action is reversible - messages can be recovered from the trash folder until they are automatically purged or manually deleted from trash.

Delete

Permanently delete the message immediately.

This action bypasses the trash folder and permanently removes the message.

Warning

This action is irreversible. Once deleted, messages cannot be recovered. Use with extreme caution and thorough testing of rule criteria.

Use Cases

• Sensitive data that should not remain in trash
• Storage optimization where trash recovery is not needed
• Automated cleanup of known disposable messages

Implementations

impl EolAction

pub fn parse(input: &str) -> Option<Self>

Parses a string into an EolAction variant.

This method provides case-insensitive parsing from string representations to EolAction variants. It’s useful for configuration file parsing, command-line arguments, and user input validation.

Arguments

• input - A string slice to parse. Case is ignored.

Returns

• Some(EolAction) if the string matches a valid variant
• None if the string is not recognized

Valid Input Strings

• "trash", "Trash", "TRASH" → EolAction::Trash
• "delete", "Delete", "DELETE" → EolAction::Delete

Examples

use cull_gmail::EolAction;

// Valid parsing (case-insensitive)
assert_eq!(EolAction::parse("trash"), Some(EolAction::Trash));
assert_eq!(EolAction::parse("TRASH"), Some(EolAction::Trash));
assert_eq!(EolAction::parse("Delete"), Some(EolAction::Delete));

// Invalid input
assert_eq!(EolAction::parse("invalid"), None);
assert_eq!(EolAction::parse(""), None);

Use Cases

use cull_gmail::EolAction;

fn parse_user_action(input: &str) -> Result<EolAction, String> {
    EolAction::parse(input)
        .ok_or_else(|| format!("Invalid action: '{}'. Use 'trash' or 'delete'.", input))
}

assert!(parse_user_action("trash").is_ok());
assert!(parse_user_action("invalid").is_err());

pub fn is_reversible(&self) -> bool

Returns true if the action is reversible (can be undone).

This method helps determine if an action allows for message recovery, which is useful for safety checks and user confirmations.

Returns

• true for EolAction::Trash (messages can be recovered from trash)
• false for EolAction::Delete (messages are permanently deleted)

Examples

use cull_gmail::EolAction;

assert!(EolAction::Trash.is_reversible());
assert!(!EolAction::Delete.is_reversible());

// Use in safety checks
let action = EolAction::Delete;
if !action.is_reversible() {
    println!("Warning: This action cannot be undone!");
}

pub fn variants() -> &'static [EolAction]

Returns all possible EolAction variants.

This method is useful for generating help text, validation lists, or iterating over all possible actions.

Returns

An array containing all EolAction variants in declaration order.

Examples

use cull_gmail::EolAction;

let all_actions = EolAction::variants();
assert_eq!(all_actions.len(), 2);
assert_eq!(all_actions[0], EolAction::Trash);
assert_eq!(all_actions[1], EolAction::Delete);

// Generate help text
println!("Available actions:");
for action in EolAction::variants() {
    println!("  {} - {}", action,
             if action.is_reversible() { "reversible" } else { "irreversible" });
}

Trait Implementations

impl Clone for EolAction

fn clone(&self) -> EolAction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EolAction

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

Formats the value using the given formatter.

impl Default for EolAction

fn default() -> EolAction

Returns the “default value” for a type.

impl Display for EolAction

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

Formats the EolAction as a lowercase string.

This implementation provides a consistent string representation for logging, configuration, and user interfaces.

Returns

• "trash" for EolAction::Trash
• "delete" for EolAction::Delete

Examples

use cull_gmail::EolAction;

assert_eq!(EolAction::Trash.to_string(), "trash");
assert_eq!(EolAction::Delete.to_string(), "delete");

// Useful for logging
let action = EolAction::default();
println!("Performing action: {}", action);

impl Hash for EolAction

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for EolAction

fn eq(&self, other: &EolAction) -> 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 Copy for EolAction

impl Eq for EolAction

impl StructuralPartialEq for EolAction