valid_toml 0.0.2

/* Copyright 2016 Joshua Gentry
 *
 * Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
 * http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
 * <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 * option. This file may not be copied, modified, or distributed
 * except according to those terms.
 */

//*************************************************************************************************
/// The states for the state machine.
enum State
{
    //---------------------------------------------------------------------------------------------
    /// The beginning of the string, we are looking for either a minus sign or a number.
    Start,

    //---------------------------------------------------------------------------------------------
    /// Reading the digits for a number.
    Number,

    //---------------------------------------------------------------------------------------------
    /// Reading the units value for the number.
    Unit
}

//*************************************************************************************************
/// A state machine for decoding a duration in the format "#d #h #m #s #ms" into the number of
/// milliseconds.
struct StateMachine
{
    //---------------------------------------------------------------------------------------------
    /// The current state of the machine.
    state : State,

    //---------------------------------------------------------------------------------------------
    /// Flag indicating we're reading a negative duration.
    negative : bool,

    //---------------------------------------------------------------------------------------------
    /// The total number of milliseconds.
    total : i64,

    //---------------------------------------------------------------------------------------------
    /// The current number we're processing.
    current : Option<i64>,

    //---------------------------------------------------------------------------------------------
    /// The current units we're processing.
    unit : String
}

impl StateMachine
{
    //*********************************************************************************************
    /// Create a new instance of the object.
    pub fn new() -> StateMachine
    {
        StateMachine {
            state    : State::Start,
            negative : false,
            total    : 0,
            current  : None,
            unit     : String::new()
        }
    }

    //*********************************************************************************************
    /// Incorporate the current value based on the value units into the total.  This method will
    /// also reset the current value to 0 and clear the units.
    ///
    /// If the units are invalid this method will return false.
    fn incorporate_current(
        &mut self
        ) -> bool
    {
        if let Some(current) = self.current.take()
        {
            let by = match self.unit.as_str()
            {
                "d"  => 24 * 60 * 60 * 1000,
                "h"  => 60 * 60 * 1000,
                "m"  => 60 * 1000,
                "s"  => 1000,
                "ms" => 1,
                _    => return false
            };

            if self.negative == false
            {
                self.total = current.saturating_mul(by).saturating_add(self.total);
            }
            else
            {
                self.total = self.total.saturating_sub(current.saturating_mul(by));
            }

            self.unit.clear();

            true
        }
        //-----------------------------------------------------------------------------------------
        // No current value.
        else
        {
            false
        }
    }

    //*********************************************************************************************
    /// Incorporates the next digit of a number into self.current.
    ///
    /// # Panics
    ///
    /// If the character is not '0' through '9' this method will panic.
    fn incorporate_val(
        &mut self,
        by : char
        )
    {
        let digit = by.to_digit(10).unwrap() as i64;

        if let Some(current) = self.current
        {
            self.current = Some(current.saturating_mul(10).saturating_add(digit));
        }
        else
        {
            self.current = Some(digit);
        }
    }

    //*********************************************************************************************
    /// Processes a character when we're in the start state.  If there is an error this method
    /// will return false.
    fn start(
        &mut self,
        ch : char
        ) -> bool
    {
        //-----------------------------------------------------------------------------------------
        // Found a negative sign, set the negative flag and start looking for numbers.
        if ch == '-'
        {
            self.negative = true;
            self.state    = State::Number;
            true
        }
        //-----------------------------------------------------------------------------------------
        // Ignore any spaces.
        else if ch == ' '
        {
            true
        }
        //-----------------------------------------------------------------------------------------
        // Found a digit, incorporate it into current and move the state to Number.
        else if ch.is_digit(10) == true
        {
            self.incorporate_val(ch);
            self.state = State::Number;
            true
        }
        //-----------------------------------------------------------------------------------------
        // Didn't find anything we recognize, return false.
        else
        {
            false
        }
    }

    //*********************************************************************************************
    /// Processes a character when we're in the Number state.
    fn number(
        &mut self,
        ch : char
        ) -> bool
    {
        //-----------------------------------------------------------------------------------------
        // The character is a digit, incorporate it into the current value.
        if ch.is_digit(10) == true
        {
            self.incorporate_val(ch);
        }
        //-----------------------------------------------------------------------------------------
        // If the character isn't a space add it to the unit string, and change the state to
        // Unit.
        else if ch != ' '
        {
            self.unit.push(ch);
            self.state = State::Unit;
        }

        true
    }

    //*********************************************************************************************
    /// Processes a character when we're in the Unit state.
    fn unit(
        &mut self,
        ch : char
        ) -> bool
    {
        //----------------------------------------------------------------------------------------
        // If the character is a space, then the unit designation is complete, incorporate the
        // current value into the total, and change the state to Number.
        if ch == ' '
        {
            if self.incorporate_current() == true
            {
                self.state = State::Number;
                true
            }
            else
            {
                false
            }
        }
        //----------------------------------------------------------------------------------------
        // If the character is a digit, then the unit designation is complete, incorporate the
        // current value into the total and incorporate the digit into the current.
        else if ch.is_digit(10)
        {
            if self.incorporate_current()
            {
                self.incorporate_val(ch);
                self.state = State::Number;
                true
            }
            else
            {
                false
            }
        }
        //----------------------------------------------------------------------------------------
        // Got another character push it into the units element.
        else
        {
            self.unit.push(ch);
            true
        }
    }

    //*********************************************************************************************
    /// Process the current character and advance the state.
    fn process(
        &mut self,
        ch : char
        ) -> bool
    {
        match self.state
        {
            State::Start => self.start(ch),
            State::Number => self.number(ch),
            State::Unit => self.unit(ch)
        }
    }

    //*********************************************************************************************
    /// Decode a string using the state machine.  If the string cannot be decoded returns None.
    pub fn decode<T : AsRef<str>>(
        mut self,
        value : T
        ) -> Option<i64>
    {
        //-----------------------------------------------------------------------------------------
        // Iterate over all the characters.
        for ch in value.as_ref().chars()
        {
            if self.process(ch) == false
            {
                return None;
            }
        }

        //-----------------------------------------------------------------------------------------
        // Incorporate the last value.
        if (self.current.is_some() || self.unit.len() > 0) && self.incorporate_current()
        {
            Some(self.total)
        }
        else
        {
            None
        }
    }
}

//*************************************************************************************************
/// Process a string and convert it into the number of milliseconds equivalent.
pub fn process<T : AsRef<str>>(
    value : T
    ) -> Option<i64>
{
    let decoder = StateMachine::new();

    decoder.decode(value)
}

#[cfg(test)]
mod tests
{
    //*********************************************************************************************
    /// Helper function to calculate what the decoder should end up with.
    fn verify(
        neg     : bool,
        days    : i64,
        hours   : i64,
        minutes : i64,
        seconds : i64,
        milli   : i64
        ) -> i64
    {
        if neg
        {
            days.saturating_mul(-24 * 60 * 60 * 1000)
                .saturating_sub(hours.saturating_mul(60 * 60 * 1000))
                .saturating_sub(minutes.saturating_mul(60 * 1000))
                .saturating_sub(seconds.saturating_mul(1000))
                .saturating_sub(milli)
        }
        else
        {
            days.saturating_mul(24 * 60 * 60 * 1000)
                .saturating_add(hours.saturating_mul(60 * 60 * 1000))
                .saturating_add(minutes.saturating_mul(60 * 1000))
                .saturating_add(seconds.saturating_mul(1000))
                .saturating_add(milli)
        }
    }

    //*********************************************************************************************
    /// Test days.
    #[test]
    fn days()
    {
        assert_eq!(super::process("4d").unwrap(), verify(false, 4, 0, 0, 0, 0));
        assert_eq!(super::process("-8d").unwrap(), verify(true, 8, 0, 0, 0, 0));
    }

    //*********************************************************************************************
    /// Test hours.
    #[test]
    fn hours()
    {
        assert_eq!(super::process("4h").unwrap(), verify(false, 0, 4, 0, 0, 0));
        assert_eq!(super::process("-8h").unwrap(), verify(true, 0, 8, 0, 0, 0));
    }

    //*********************************************************************************************
    /// Test minutes.
    #[test]
    fn minutes()
    {
        assert_eq!(super::process("4m").unwrap(), verify(false, 0, 0, 4, 0, 0));
        assert_eq!(super::process("-8m").unwrap(), verify(true, 0, 0, 8, 0, 0));
    }

    //*********************************************************************************************
    /// Test seconds.
    #[test]
    fn seconds()
    {
        assert_eq!(super::process("4s").unwrap(), verify(false, 0, 0, 0, 4, 0));
        assert_eq!(super::process("-8s").unwrap(), verify(true, 0, 0, 0, 8, 0));
    }

    //*********************************************************************************************
    /// Test seconds.
    #[test]
    fn milliseconds()
    {
        assert_eq!(super::process("4ms").unwrap(), verify(false, 0, 0, 0, 0, 4));
        assert_eq!(super::process("-8ms").unwrap(), verify(true, 0, 0, 0, 0, 8));
    }

    //*********************************************************************************************
    /// Test various combinations.
    #[test]
    fn combo()
    {
        assert_eq!(super::process("12d 10h 8m 6s 4ms").unwrap(), verify(false, 12, 10, 8, 6, 4));
        assert_eq!(super::process("-12d 10h 8m 6s 4ms").unwrap(), verify(true, 12, 10, 8, 6, 4));

        assert_eq!(super::process("12d 4ms").unwrap(), verify(false, 12, 0, 0, 0, 4));
        assert_eq!(super::process("-10h 6s").unwrap(), verify(true, 0, 10, 0, 6, 0));
    }

    //*********************************************************************************************
    /// Test various combinations with spaces in interesting places.
    #[test]
    fn spaces()
    {
        assert_eq!(super::process("  -6s3ms").unwrap(), verify(true, 0, 0, 0, 6, 3));
        assert_eq!(super::process("12d10h8m6s4ms").unwrap(), verify(false, 12, 10, 8, 6, 4));

        assert_eq!(super::process("12 d 4   ms").unwrap(), verify(false, 12, 0, 0, 0, 4));
        assert_eq!(super::process("-   10h 6  s").unwrap(), verify(true, 0, 10, 0, 6, 0));
    }

    //*********************************************************************************************
    /// Test bad values.
    #[test]
    fn bad()
    {
        assert!(super::process("abc").is_none());
        assert!(super::process("123").is_none());
        assert!(super::process("123u").is_none());
        assert!(super::process("12h 123").is_none());
        assert!(super::process("12u 123m").is_none());
        assert!(super::process("12u123m").is_none());
        assert!(super::process("h0").is_none());
        assert!(super::process("-3").is_none());
        assert!(super::process("-h").is_none());
        assert!(super::process("h").is_none());
        assert!(super::process("-3h-6m").is_none());
        assert!(super::process("-3h m").is_none());
    }
}