valid_toml/

toml_iter.rs

/* 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.
 */
use std::collections::BTreeMap;
use std::collections::btree_map::Iter;
use std::iter::Peekable;

use toml::Value;

use item_def::ItemDef;
use notify::Notify;

//*************************************************************************************************
/// Internal state for the iterator.
enum State
{
    //---------------------------------------------------------------------------------------------
    /// Normal (success) state, we have an item along with it's definition.
    Normal,

    //---------------------------------------------------------------------------------------------
    /// We've finished the iterator.
    Done,

    //---------------------------------------------------------------------------------------------
    /// We've encountered an item that does not have a definition.
    UnknownInput,

    //---------------------------------------------------------------------------------------------
    /// We've encountered an definition that does not have an item.
    MissingInput
}

//*************************************************************************************************
/// Returns the value from the next iteration.
pub enum Next<'a, 'b, 'c>
{
    //---------------------------------------------------------------------------------------------
    /// We have an item and it's definition.
    NextItem(&'a String, &'a Value, &'b Box<ItemDef>, Option<&'c Box<Notify>>),

    //---------------------------------------------------------------------------------------------
    /// The next item in the input doesn't have a matching definition.
    UnknownInput(&'a String, &'a Value),

    //---------------------------------------------------------------------------------------------
    /// We have a definition but no matching input item.
    MissingInput(&'b String, &'b Box<ItemDef>, Option<&'c Box<Notify>>),

}

//*************************************************************************************************
/// This object iterates over three BTreeMap iterators and keeps them in sync by comparing the
/// keys.  This is possible since the BTreeMap keeps the keys in the same order.
pub struct TomlIter<'a, 'b, 'c>
{
    //---------------------------------------------------------------------------------------------
    /// The iterator iterating over the values read from the TOML file.
    input_iter : Peekable<Iter<'a, String, Value>>,

    //---------------------------------------------------------------------------------------------
    /// The iterator iterating over the definitions for the items.
    define_iter : Peekable<Iter<'b, String, Box<ItemDef>>>,

    //---------------------------------------------------------------------------------------------
    /// The iterator iterating over the notifications we need to make.
    notify_iter : Peekable<Iter<'c, String, Box<Notify>>>
}

impl<'a, 'b, 'c> TomlIter<'a, 'b, 'c>
{
    //*********************************************************************************************
    /// Construct a new instance of the object.
    pub fn new(
        input : &'a BTreeMap<String, Value>,
        define : &'b BTreeMap<String, Box<ItemDef>>,
        notify : &'c BTreeMap<String, Box<Notify>>
        ) -> TomlIter<'a, 'b, 'c>
    {
        TomlIter {
            input_iter  : input.iter().peekable(),
            define_iter : define.iter().peekable(),
            notify_iter : notify.iter().peekable()
        }
    }

    //*********************************************************************************************
    /// Determines the current state of the iterator.
    fn state(&mut self) -> State
    {
        let input      = self.input_iter.peek();
        let definition = self.define_iter.peek();

        //-----------------------------------------------------------------------------------------
        // Neither the input iterator or the definition iterator has completed, compare the
        // names to see what the state is.
        if input.is_some() && definition.is_some()
        {
            let &(input_name, _) = input.unwrap();
            let &(def_name, _)   = definition.unwrap();

            //-------------------------------------------------------------------------------------
            // If the input name is before the definition name, then we don't have a definition
            // for the input.
            if input_name < def_name
            {
                State::UnknownInput
            }
            //-------------------------------------------------------------------------------------
            // If the definition name is before the ionput name, then we are missing an element
            // from the input.
            else if def_name < input_name
            {
                State::MissingInput
            }
            //-------------------------------------------------------------------------------------
            // The names are equal, we're in a "normal" state.
            else
            {
                State::Normal
            }
        }
        //-----------------------------------------------------------------------------------------
        // If there is an input (and no definition) then we have an input value without a matching
        // definition.
        else if input.is_some()
        {
            State::UnknownInput
        }
        //-----------------------------------------------------------------------------------------
        // If there is a definition (and no input) then we're missing an input.
        else if definition.is_some()
        {
            State::MissingInput
        }
        //-----------------------------------------------------------------------------------------
        // Both iterators are none, so we're done.
        else
        {
            State::Done
        }
    }

    //*********************************************************************************************
    /// Checks if we have a notification for the specified name.
    fn notification(
        &mut self,
        name : &String
        ) -> Option<&'c Box<Notify>>
    {
        if let Some(&(notify_name, _)) = self.notify_iter.peek()
        {
            if name == notify_name
            {
                let (_, notify_value) = self.notify_iter.next().unwrap();

                Some(notify_value)
            }
            else
            {
                None
            }
        }
        else
        {
            None
        }
    }

    //*********************************************************************************************
    /// We have an item with no defintion, construct the UnknownInput enum to return to the client.
    fn unknown_item(&mut self) -> Next<'a, 'b, 'c>
    {
        let (name, value) = self.input_iter.next().unwrap();

        Next::UnknownInput(name, value)
    }

    //*********************************************************************************************
    /// We have a definition without an input, construct the MissingInput enum to return to the
    /// client.  Also check if there is a notification that needs to go out with it.
    fn missing_item(&mut self) -> Next<'a, 'b, 'c>
    {
        let (name, value) = self.define_iter.next().unwrap();
        let notify        = self.notification(name);

        Next::MissingInput(name, value, notify)
    }

    //*********************************************************************************************
    /// Normal state we have an item and a definition, also check if there is a notification that
    /// needs to go out with it.
    fn next_item(&mut self) -> Next<'a, 'b, 'c>
    {
        let (name, value) = self.input_iter.next().unwrap();
        let (_, define)   = self.define_iter.next().unwrap();
        let notify        = self.notification(name);

        Next::NextItem(name, value, define, notify)
    }

    //*********************************************************************************************
    /// Returns the next item from the interator.
    pub fn next(&mut self) -> Option<Next>
    {
        match self.state()
        {
            State::Normal       => Some(self.next_item()),
            State::Done         => None,
            State::UnknownInput => Some(self.unknown_item()),
            State::MissingInput => Some(self.missing_item())
        }
    }
}

#[cfg(test)]
mod tests
{
    use std::collections::BTreeMap;

    use toml::Value;

    use data::ItemUsize;
    use item_def::ItemDef;
    use notify::Notify;
    use value::UsizeValue;

    macro_rules! assert_item {
        ($test:expr, $name:expr, $val:expr, $notify:expr) => {{
            match $test.unwrap()
            {
                super::Next::NextItem(name, value, def, notify) => {
                    assert_eq!(name, $name);
                    assert_eq!(def.name(), name);
                    assert_eq!($val, value.as_integer().unwrap());

                    if $notify
                    {
                        assert!(notify.is_some());
                    }
                    else
                    {
                        assert!(notify.is_none());
                    }
                },
                _ => {
                    panic!("{} not found.", $name);
                }
            }
        }}
    }

    macro_rules! assert_unknown {
        ($test:expr, $name:expr, $val:expr) => {{
            match $test.unwrap()
            {
                super::Next::UnknownInput(name, value) => {
                    assert_eq!(name, $name);
                    assert_eq!($val, value.as_integer().unwrap());
                },
                _ => {
                    panic!("{} is known.", $name);
                }
            }
        }}
    }

    macro_rules! assert_missing {
        ($test:expr, $name:expr, $notify:expr) => {{
            match $test.unwrap()
            {
                super::Next::MissingInput(name, def, notify) => {
                    assert_eq!(name, $name);
                    assert_eq!(def.name(), name);

                    if $notify
                    {
                        assert!(notify.is_some());
                    }
                    else
                    {
                        assert!(notify.is_none());
                    }
                },
                _ => {
                    panic!("{} is not missing.", $name);
                }
            }
        }}
    }

    //*********************************************************************************************
    /// Helper method to generate the 3 BTree maps we need to iterate over.
    fn generate(
        mut data : Vec<(&str, i64)>
        ) -> (BTreeMap<String, Value>, BTreeMap<String, Box<ItemDef>>, BTreeMap<String, Box<Notify>>)
    {
        let mut input  : BTreeMap<String, Value>        = BTreeMap::new();
        let mut define : BTreeMap<String, Box<ItemDef>> = BTreeMap::new();
        let mut notify : BTreeMap<String, Box<Notify>>  = BTreeMap::new();

        for (name, value) in data.drain(..)
        {
            input.insert(String::from(name), Value::Integer(value));
            define.insert(String::from(name), Box::new(ItemUsize::with_name(name)));
            notify.insert(String::from(name), Box::new(UsizeValue::new()));
        }

        (input, define, notify)
    }

    //*********************************************************************************************
    /// "Normal" case everything exists.
    #[test]
    fn normal()
    {
        let (input, define, notify) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);
        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_item!(test.next(), "a", 1, true);
        assert_item!(test.next(), "b", 2, true);
        assert_item!(test.next(), "c", 3, true);
        assert_item!(test.next(), "d", 4, true);
        assert!(test.next().is_none());
    }

    //*********************************************************************************************
    /// Test with no notification elements.
    #[test]
    fn no_notify()
    {
        let (input, define, _) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);
        let notify = BTreeMap::new();
        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_item!(test.next(), "a", 1, false);
        assert_item!(test.next(), "b", 2, false);
        assert_item!(test.next(), "c", 3, false);
        assert_item!(test.next(), "d", 4, false);
        assert!(test.next().is_none());
    }

    //*********************************************************************************************
    /// Test with no define elements.
    #[test]
    fn no_define()
    {
        let (input, _, _) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);
        let define = BTreeMap::new();
        let notify = BTreeMap::new();
        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_unknown!(test.next(), "a", 1);
        assert_unknown!(test.next(), "b", 2);
        assert_unknown!(test.next(), "c", 3);
        assert_unknown!(test.next(), "d", 4);
        assert!(test.next().is_none());
    }

    //*********************************************************************************************
    /// Test with no values.
    #[test]
    fn no_values()
    {
        let (_, define, notify) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);
        let input = BTreeMap::new();
        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_missing!(test.next(), "a", true);
        assert_missing!(test.next(), "b", true);
        assert_missing!(test.next(), "c", true);
        assert_missing!(test.next(), "d", true);
        assert!(test.next().is_none());
    }

    //*********************************************************************************************
    /// Test with the first value missing.
    #[test]
    fn missing_first()
    {
        let (mut input, define, notify) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);

        input.remove("a");

        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_missing!(test.next(), "a", true);
        assert_item!(test.next(), "b", 2, true);
        assert_item!(test.next(), "c", 3, true);
        assert_item!(test.next(), "d", 4, true);
        assert!(test.next().is_none());
    }

    //*********************************************************************************************
    /// Test with a middle value missing.
    #[test]
    fn missing_middle()
    {
        let (mut input, define, notify) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);

        input.remove("b");

        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_item!(test.next(), "a", 1, true);
        assert_missing!(test.next(), "b", true);
        assert_item!(test.next(), "c", 3, true);
        assert_item!(test.next(), "d", 4, true);
        assert!(test.next().is_none());
    }

    //*********************************************************************************************
    /// Test with the lat value missing.
    #[test]
    fn missing_last()
    {
        let (mut input, define, notify) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);

        input.remove("d");

        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_item!(test.next(), "a", 1, true);
        assert_item!(test.next(), "b", 2, true);
        assert_item!(test.next(), "c", 3, true);
        assert_missing!(test.next(), "d", true);
        assert!(test.next().is_none());
    }

    //*********************************************************************************************
    /// Test with the first item being undefined.
    #[test]
    fn undefined_first()
    {
        let (input, mut define, mut notify) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);

        define.remove("a");
        notify.remove("a");

        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_unknown!(test.next(), "a", 1);
        assert_item!(test.next(), "b", 2, true);
        assert_item!(test.next(), "c", 3, true);
        assert_item!(test.next(), "d", 4, true);
        assert!(test.next().is_none());
    }

    //*********************************************************************************************
    /// Test with a middle value being undefined.
    #[test]
    fn undefined_middle()
    {
        let (input, mut define, mut notify) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);

        define.remove("b");
        notify.remove("b");

        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_item!(test.next(), "a", 1, true);
        assert_unknown!(test.next(), "b", 2);
        assert_item!(test.next(), "c", 3, true);
        assert_item!(test.next(), "d", 4, true);
        assert!(test.next().is_none());
    }

    //*********************************************************************************************
    /// Test with the last value being undefined.
    #[test]
    fn undefined_last()
    {
        let (input, mut define, mut notify) = generate(vec![("a", 1), ("b", 2), ("c", 3), ("d", 4)]);

        define.remove("d");
        notify.remove("d");

        let mut test = super::TomlIter::new(&input, &define, &notify);

        assert_item!(test.next(), "a", 1, true);
        assert_item!(test.next(), "b", 2, true);
        assert_item!(test.next(), "c", 3, true);
        assert_unknown!(test.next(), "d", 4);
        assert!(test.next().is_none());
    }

}