args 2.2.0

An argument parsing and validation library designed to take some of tediousness out of the general 'getopts' crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! A module containing enums and traits associated with argument validation.

use std::fmt::{self,Display,Formatter};

#[cfg(test)] mod tst;

use super::ArgsError;

/// A trait designed to provide validation for command line argument parsing.
pub trait Validation {
    /// The `type` (e.g. `i32`, `String`, etc.) to which the validation is applied.
    type T;

    // Instance methods
    /// Returns an `ArgsError` describing the invalid state for the provided `value`.
    fn error(&self, value: &Self::T) -> ArgsError;
    /// Returns a `bool` indicating if the `Validation` passes for the provided `value`.
    fn is_valid(&self, value: &Self::T) -> bool;

    // Defaulted instance methods
    /// Returns a `bool` indicating if the `Validation` fails for the provided `value`.
    fn is_invalid(&self, value: &Self::T) -> bool { !self.is_valid(value) }
}

/// The relationship to use when validating an `OrderValidation`.
pub enum Order {
    /// Represents a strictly greater than relationship.
    GreaterThan,
    /// Represents a greater than relationship that allows equality.
    GreaterThanOrEqual,
    /// Represents a strictly less than relationship.
    LessThan,
    /// Represents a less than relationship that allows equality.
    LessThanOrEqual
}

impl Order {
    /// Compares the provided `value` to the provided `bound`
    pub fn compare<T: PartialOrd>(&self, bound: &T, value: &T) -> bool {
        match *self {
            Order::GreaterThan => { value > bound },
            Order::GreaterThanOrEqual => { value >= bound },
            Order::LessThan => { value < bound },
            Order::LessThanOrEqual => { value <= bound }
        }
    }
}

impl Display for Order {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        let display = match *self {
            Order::GreaterThan => { "greater than" },
            Order::GreaterThanOrEqual => { "greater than or equal to" },
            Order::LessThan => { "less than" },
            Order::LessThanOrEqual => { "less than or equal to" }
        };
        write!(f, "{}", display)
    }
}

/// An implementation of `Validation` which tests whether or not a value adheres
/// to the provided `order` and `bound`. It should be noted that the type of
/// `bound`, `O`, must implement `Clone`, `Display` **and** `PartialOrd`.
///
/// # Examples
///
/// ```rust
/// use args::validations::{Order,OrderValidation,Validation};
///
/// let validation = OrderValidation::new(Order::GreaterThan, 0u32);
/// validation.is_valid(&1u32); // true
/// validation.is_valid(&0u32); // false
///
/// if validation.is_invalid(&0u32) {
///     // do things
///     println!("{}", validation.error(&0u32));
/// }
/// ```
pub struct OrderValidation<O: Clone + Display + PartialOrd> {
    bound: O,
    order: Order
}

impl<O: Clone + Display + PartialOrd> OrderValidation<O> {
    /// Creates a new `OrderValidation` with the provided `order` and `bound`.
    pub fn new(order: Order, bound: O) -> OrderValidation<O> {
        OrderValidation { bound: bound.clone(), order: order }
    }
}

impl<O: Clone + Display + PartialOrd> Validation for OrderValidation<O> {
    type T = O;

    fn error(&self, value: &O) -> ArgsError {
        ArgsError::new("order invalid", &format!("{} is not {} {}", value, self.order, self.bound))
    }

    fn is_valid(&self, value: &O) -> bool {
        self.order.compare(&self.bound, value)
    }
}