sml/

lib.rs

//! # SML
//! 
//! `SML` is a simple markup language designed to convert human readable information into Rust
//! types with a very specific purpose of loading config files and schemas.
//!
//! The format looks like
//! 
//! ```text
//! hobbit:
//!     name:           Frodo Baggins
//!     age:            98
//!     friends:
//!         hobbit:
//!             name:   Bilbo Baggins
//!             age:    176
//!         hobbit:
//!             name:   Samwise Gamgee
//!             age:    66
//! ```
//!
//! ## Data Format Rules
//! 
//! 1. Indentation has meaning and is 4 spaces, relative to the top key. If indenting is relative
//!    to the top key, then you can neatly align strings embedded in code.
//! 
//! 2. All values must be double quoted.
//! 
//! 3. Key/value combinations are used for fields
//! ```text
//! name: "Frodo"
//! ```
//! are used for `struct` fields and `enum` variants. Keys only
//! ```text
//! hobbit:
//!     name: "Frodo"
//! ```
//! indicate a complete `struct` or `enum`. In this way, the data clearly indicates the mapping to
//! Rust data structures.
//! 
//! 4. Separation of lines has meaning.
//! 
//! 5. Keys must not include but must be followed by a colon `:`.
//! 
//! 6. Double quotes in values must be escaped using `\"`.
//! 
//! 7. Everything after the second double quote is ignored.
//! 
//! 8. Empty lines or lines with whitespace only are ignored.
//!
//! 9. Comments require `//` at the start of the line for example
//!
//! ```text
//! // comment
//! hobbit:
//!     name: "Frodo"
//! ```
//! 
//! ## Example. From `Small`-formatted string to your data-structure.
//!
//! This examples should cover 90 percent of use cases.
//! 
//! ```rust
//! use sml::{Small, FromSmall, SmallError};
//! 
//! #[derive(Debug)]
//! struct Hobbit {
//!     name:    String,
//!     age:     u32,
//!     friends: Vec<Hobbit>,
//!     bicycle: Option<String>,
//! }
//! 
//! impl FromSmall for Hobbit {
//!     fn from_small(s: &Small) -> Result<Self, SmallError> {
//!         Ok(Hobbit {
//!             name:    String::path(&s, "hobbit::name")?,
//!             age:     u32::path(&s, "hobbit::age")?,
//!             friends: Vec::<Hobbit>::path(&s, "hobbit::friends::hobbit")?,
//!             bicycle: Option::<String>::path(&s, "hobbit::bicycle")?,
//!         })
//!     }
//! }
//! 
//! fn main() {
//!     let s = r#"
//!         hobbit:
//!             name:         "Frodo Baggins"
//!             age:          "98"
//!             friends:
//!                 hobbit:
//!                     name: "Bilbo Baggins"
//!                     age:  "176"
//!                 hobbit:
//!                     name: "Samwise Gamgee"
//!                     age:  "66""#;
//!     
//!     let frodo = Hobbit::from_str_debug(s);
//!     println!("name: {}", frodo.name);
//! }
//! ```
//!
//! ## `FromSmall` Trait
//! Types that implement the `FromSmall` trait can be constructed from a `Small`-formatted string.
//!
//! Required function:
//! ```rust
//! from_small(slice: &Small) -> Result<Self, SmallError>
//! ```
//! The `from_small()` function describes how to create a data-structure from the parts of
//! `Small`.
//!
//! ```rust
//! path(small: &Small, key_path: &str) -> Result<Self, SmallError>
//! ```
//! Reduces `Small` to the `key_path` and then uses the `FromSmall` trait to convert to the
//! receiver type.
//!
//! ```rust
//! from_str(s: &str) -> Result<Self, SmallError>
//! ```
//! Top level function that convert a `Small`-formatted string into the receiver.
//!
//! ```rust
//! from_str_debug(s: &str) -> Self
//! ```
//! Top level function that converts a `Small`-formatted string into the receiver giving helpful
//! error messages for debugging.
//!
//! # Implementation
//!
//! A `Small` value may be a collection of `Small` values. For example,
//!
//! ```text
//! hobbit:
//!     name: "Bilbo Baggins"
//!     age:  "176"
//! hobbit:
//!     name: "Samwise Gamgee"
//!     age:  "66"
//! ```
//! is a collection of two elements
//! ```text
//! hobbit:
//!     name: "Bilbo Baggins"
//!     age:  "176"
//! ```
//! and 
//! ```text
//! hobbit:
//!     name: "Samwise Gamgee"
//!     age:  "66"
//! ```
//! Often when implementing `FromSmall` we want to convert a `Small` object into a single value, so
//! we need to check that `Small` has only one element The implementation to convert from `Small`
//! to `u32` gives indicates how to do this. `unique_value()` checks that there is only one element
//! in `Small` and if so returns that one element and `value()` extracts that value as a `String`.
//!
//! ```rust
//! impl FromSmall for u32 {
//!     fn from_small(s: &Small) -> Result<Self, SmallError> {
//!         let token = s.unique_value()?;
//!         token
//!             .value()?
//!             .parse::<u32>()
//!             .map_err(|_| SmallError::ParseValue(token, "u32"))
//!     }
//! }
//! ```

// #![feature(try_trait)]

use colored::Colorize;
use core::str::Split;
use std::error::Error;
use std::fmt::Display;
use std::ops::Index;
use std::fmt;
use std::process::exit;

const INDENTSTEP: usize = 4;

fn spaces(i: usize) -> String {
    let mut s = String::new();
    for _n in 0..i { s.push_str(" ") };
    s
}

// The line number of the error be found in `Token`.
#[derive(Debug, PartialEq)]
pub enum SmallError {
    ///
    /// Expected a key but could not find it. Holds the `Token` that failed to parse and the
    /// position in the line of the following colon.
    ///
    EmptyKey(Token, usize), 

    ///
    /// Indentation should be aligned by 4 to the top key. `usize` refers to the indent of the top
    /// key in the original string.
    ///
    Indent(Token, usize),

    ///
    /// The input string is empty.
    ///
    Empty,

    /// 
    /// Expected key/value pair but found a key only. Holds the `Token` that failed to parse.
    ///
    IsKey(Token),

    /// 
    /// Expected a key but found a key/value pair.
    ///
    IsValue(String),

    ///
    /// Failed to parse a key path.
    ///
    KeyParse(String),

    ///
    /// Expected a unique key or key/value pair but could not find it.
    ///
    MissingToken,

    ///
    /// Expected a colon after the key. Holds the `Token` that failed to parse and the position
    /// where a colon was expected.
    ///
    NoColon(Token, usize),

    ///
    /// Values should start with a double quotemark. Holds the `Token` that failed to parse and a
    /// `usize` of the expected position of the quote.
    ///
    NoQuoteAfterKey(Token, usize),

    ///
    /// Values should end with a double quotemark. Holds the `Token` that failed to parse and a
    /// `usize` of the expected position of the second quote.
    ///
    NoSecondQuote(Token, usize),

    ///
    /// Keys and Values should be separated by at least one space. Holds the `Token` that failed to
    /// parse.
    ///
    NoSpaceAfterKey(Token),

    ///
    /// Expected one key but found many. Holds a `usize` of the number of keys.
    ///
    NotUnique(usize),

    ///
    /// Could not parse the string. Holds the `Token` that failed to parse.
    ///
    ParseValue(Token, &'static str),

    ///
    /// Keys should not contain double quotemarks. Holds the `Token` that failed to parse and a
    /// `usize` of the position of the double quote.
    ///
    QuotemarkInKey(Token, usize),  // usize refers to position of quote.

    ///
    /// For use by client code.
    ///
    User(String),
}

impl Error for SmallError {
}

impl fmt::Display for SmallError {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            SmallError::Empty => {
                write!(f, "The input string is empty.")
            },

            SmallError::EmptyKey(token, pos) => {
                write!(f, "Line {}:{} Empty key.", token.line, pos)
            },

            SmallError::Indent(token, _) => {
                write!(f, "Line {}:{} Indentation should be aligned by {} to the top key ",
                    token.line,
                    token.start_key.unwrap(),
                    INDENTSTEP
                )
            },

            SmallError::IsKey(s) => {
                write!(f, "Expected 'key: value' but found only key \"{}\"", s)
            },

            SmallError::IsValue(s) => {
                write!(f, "\"{}\" is a value, not a key.", s)
            },

            SmallError::ParseValue(token, to_type) => {
                write!(f, "Line {}:{} [{}] The value could not be parsed into a {}.",
                       token.line,
                       token.start_val.unwrap(),
                       token.text.trim().cyan().bold(),
                       to_type,
                )
            },

            SmallError::KeyParse(s) => {
                write!(f,
                       "\"{}\" cannot be parsed.", s)
            },

            SmallError::NoColon(token, pos) => {
                write!(f, "Line {}: [{}] should have a colon after the key at position {}.", token.line, token.text, pos)
            },

            SmallError::NotUnique(n) => {
                write!(f,
                       "Resulted in {} keys, but expected 1.", n)
            },

            SmallError::NoQuoteAfterKey(token, pos) => {
                write!(f, "Line {}:{} Value must start with double quotemark", token.line, pos)
            },

            SmallError::NoSecondQuote(token, pos) => {
                write!(f, "Line {}:{} No second quote.", token.line, pos)
            },

            SmallError::NoSpaceAfterKey(token) => {
                write!(f, "Line {}:{} No space after .", token.line, token.end_key.unwrap())
            },

            SmallError::MissingToken => {
                write!(f, "Expected another token.")
            },

            SmallError::QuotemarkInKey(token, pos) => {
                write!(f, "Line {}:{} Quote mark in key.", token.line, pos)
            },

            SmallError::User(s) => {
                write!(f, "{}", s)
            },        
        }
    }
}

// A `KeyPath` looks like "hobbit::friends::name".
#[derive(Debug)]
pub struct KeyPath<'a>(&'a str, Split<'a, &'a str>);

impl<'a> KeyPath<'a> {
    pub fn from_str(s: &'a str) -> Result<Self, SmallError> {
        if s.is_empty() { return Err(SmallError::KeyParse(s.to_owned())) };
        if s.split("::").any(|k| k.contains(":")) {
           return Err(SmallError::KeyParse(s.to_owned()))
        };
        Ok(KeyPath(s, s.split("::")))
    }
}

impl<'a> fmt::Display for KeyPath<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl<'a> Iterator for KeyPath<'a> {
    type Item = &'a str;
    fn next(&mut self) -> Option<Self::Item> {
        self.1.next()
    }
}

/// The `Token` struct contains implementation details of a parsed line a `Small`-formatted string.
/// It is not really part of the API, but gets passed around by `SmallError` and as such is public.
//
// Parsing makes one scan of the line from left to right. Options are required in the struct for
// when a string fails to parse. In this case partial information is used to create error feedback
// from the earlier part of the parse even if the later part of the parse is not complete.
//
//     a__long_key:            "Bilbo Baggins"
//     ^          ^            ^             ^
//     start_key  end_key      start_val     end_val
//
#[derive(Clone, Debug)]
pub struct Token {
    text:      String,        
    line:      usize,         
    start_key: Option<usize>, 
    end_key:   Option<usize>, 
    start_val: Option<usize>, 
    end_val:   Option<usize>, 
}

// PartialEq requires same indentation, and same key and value, but is otherwise flexible on
// spacing.
impl PartialEq for Token {
    fn eq(&self, other: &Token) -> bool {
        self.indentation() == other.indentation() &&
        self.key() == other.key() &&
        self.value() == other.value()
    }
}

// Parser State
#[derive(Debug)]
enum PS {
    BK,       // Before key.
    IK,       // In key.
    RAK,      // Right after key.
    AK,       // After key.
    IV,       // In value.
    AV,       // After value.
}

impl Token {

    // Its worth having this constructor as it reduces verbosity in the Token::from_str() parsing
    // function.
    fn new(
        text:       &str,
        line:       usize,
        start_key:  Option<usize>,
        end_key:    Option<usize>,
        start_val:  Option<usize>,
        end_val:    Option<usize>) -> Self {

        Token {
            text:       text.to_string(),
            line:       line,
            start_key:  start_key,
            end_key:    end_key,
            start_val:  start_val,
            end_val:    end_val,
        }
    }

    fn indent(&mut self) {
        self.text = format!("    {}", self.text);
        self.start_key = self.start_key.map(|sk| sk + INDENTSTEP);
        self.end_key   = self.end_key.map(|ek| ek + INDENTSTEP);
        self.start_val = self.start_val.map(|sv| sv + INDENTSTEP);
        self.end_val   = self.end_val.map(|ev| ev + INDENTSTEP);
    }

    // Parses a line of text and return a Token. Iterate over the characters, one at a time. The
    // parse state (enum PS) changes as we go through the string. This function trims the string.
    // String::from_str() is responsible for trimming whitespace.
    fn from_str(s: &str, line: usize, root_indent: usize) -> Result<Self, SmallError> {
        let mut ps = PS::BK;
        let mut escape = false;
        let mut start_key:   Option<usize> = None;
        let mut end_key:     Option<usize> = None;
        let mut start_val:   Option<usize> = None;
        let mut end_val:     Option<usize> = None;

        for (pos, c) in s.char_indices() {

            // Before key.
            if let PS::BK = ps {
                if c == ':' {
                    start_key = Some(pos);
                    let token = Token::new(s, line, start_key, end_key, start_val, end_val);
                    return Err(SmallError::EmptyKey(token, pos));
                };
                if !c.is_whitespace() {
                    start_key = Some(pos);
                    if (pos - root_indent) % INDENTSTEP != 0 {
                        let token = Token::new(s, line, start_key, end_key, start_val, end_val);
                        return Err(SmallError::Indent(token, root_indent));
                    };
                    ps = PS::IK;
                };
                continue; // Next char.
            };

            // In key.
            if let PS::IK = ps {
                if c == '"' {
                    let token = Token::new(s, line, start_key, end_key, start_val, end_val);
                    return Err(SmallError::QuotemarkInKey(token, pos));
                };
                if c.is_whitespace() {
                    let token = Token::new(s, line, start_key, end_key, start_val, end_val);
                    return Err(SmallError::NoColon(token, pos));
                };
                if c == ':' {
                    if Some(pos) == start_key {
                        let token = Token::new(s, line, start_key, end_key, start_val, end_val);
                        return Err(SmallError::EmptyKey(token, pos))
                    } else {
                        end_key = Some(pos);
                        ps = PS::RAK;
                        continue;
                    };
                };
            };

            // Right after key.
            if let PS::RAK = ps {
                if !c.is_whitespace() {
                    let token = Token::new(s, line, start_key, end_key, start_val, end_val);
                    return Err(SmallError::NoSpaceAfterKey(token))
                } else {
                    ps = PS::AK;
                    continue;
                }
            };

            // After key.
            if let PS::AK = ps {
                if c.is_whitespace() {
                    continue;
                } else {
                    if c != '"' {
                        let token = Token::new(s, line, start_key, end_key, start_val, end_val);
                        return Err(SmallError::NoQuoteAfterKey(token, pos))
                    } else {
                        start_val = Some(pos);
                        ps = PS::IV;
                        continue;
                    }
                }
            };

            // In value.
            if let PS::IV = ps {
                if c == '\\' {
                    escape = true;
                } else if c == '"' && escape {
                        continue;
                } else if c == '"' {
                    ps = PS::AV;
                    end_val = Some(pos);
                } else {
                    escape = false;
                    continue;
                }
            };

            // After value.
            if let PS::AV = ps { break };
        };

        let token = Token::new(s, line, start_key, end_key, start_val, end_val);

        match ps {
            PS::BK  => { 
                panic!("Shouldn't fail here")
            },
            PS::IK  => { Err(SmallError::NoColon(token, s.char_indices().count())) },
            PS::RAK => { Ok(token) },
            PS::AK  => { Ok(token) },
            PS::IV  => { return Err(SmallError::NoSecondQuote(token, s.char_indices().count())) },
            PS::AV  => { Ok(token) },
        }
    }

    fn key(&self) -> String {
        self.text[self.start_key.unwrap()..=self.end_key.unwrap() - 1].to_string()
    }

    // This function shouldn't fail, as indentation should be checked during parsing.
    fn indentation(&self) -> usize {
        self.start_key.expect("Bug: start_key was None but should always be Some.")
    }

    fn line(&self) -> usize {
        self.line
    }

    fn is_value(&self) -> bool {
        if let (Some(_), Some(_), Some(_), Some(_)) = 
            (self.start_key, self.end_key, self.start_val, self.end_val) {
                true
            } else {
                false
            }
    }

    pub fn value(&self) -> Result<String, SmallError> {
        if self.is_value() {
            Ok(self.text[self.start_val.unwrap() + 1..=self.end_val.unwrap() - 1].to_string())
        } else {
            Err(SmallError::IsKey(self.clone()))
        }
    }
}

impl Display for Token {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{}", self.text)
    }
}

/// `SmallString` represents a string in `Small` data format.
#[derive(Debug)]
pub struct SmallString(Vec<Token>);

fn empty_line(line: &str) -> bool {
    line.starts_with("//") ||
    !line.chars().any(|c| !c.is_whitespace())
}

impl SmallString {
    
    // Create a `SmallString` structure from a string.
    pub fn from_str(s: &str) -> Result<Self, SmallError> {

        let mut v                 = Vec::new();
        let mut before_start_line = true;
        let mut root_indent       = 0;
        let mut line_num          = 0;

        for ln in s.lines() {
            if empty_line(ln) { continue };
            
            // First line.
            if before_start_line == true {
                root_indent = ln.chars().position(|c| !c.is_whitespace()).unwrap();
                before_start_line = false;
            };
            v.push(Token::from_str(ln, line_num, root_indent)?);
            line_num += 1;
        };
        if v.is_empty() { Err(SmallError::Empty) } else { Ok(SmallString(v)) }
    }

    fn indent(&mut self) {
        for token in self.0.iter_mut() {
            token.indent();
        }
    }

    /// Converts `self` into a `Small`. 
    pub fn to_ref(&self) -> Small {
        Small {
            small:      self,
            reduction:  vec!(&self.0[..]),
        }
    }

    // Calculate the position of the value column to vertically align keys.
    fn max_key_end(&self) -> (usize, usize) {
        let root_indent = self.0[0].indentation();
        let max_end_key = self.0.iter().map(|token| token.end_key.unwrap()).max().unwrap();
        (root_indent, max_end_key - root_indent)
    }
}

impl Index<usize> for SmallString {
    type Output = Token;

    fn index(&self, i: usize) -> &Token {
        &self.0[i]
    }
}

impl fmt::Display for SmallString {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let (root_indent, max_key_end) = self.max_key_end();
        let mut s = String::new();

        // Vertically align the values.
        for token in self.0.iter() {
            let val_shift: Option<i32> = match token.start_val {
                Some(sv) => Some((max_key_end + 1) as i32 - sv as i32),
                None     => None,
            };
            let (start_val, end_val) = match (token.start_val, token.end_val, val_shift) {
                (Some(sv), Some(ev), Some(vs)) => {
                    (Some((sv as i32 + vs as i32) as usize), Some((ev as i32 + vs as i32) as usize))
                },
                _ => {
                    (None, None)
                },
            };
            let new_token = Token {
                text:       token.text.clone(),
                line:       token.line,
                start_key:  Some(token.start_key.unwrap() - root_indent),
                end_key:    Some(token.end_key.unwrap() - root_indent),
                start_val:  start_val,
                end_val:    end_val,
            };
            s.push_str(&format!("{}\n", new_token.to_string()));
        };
        s.pop();
        write!(f, "{}", s)
    }
}

/// `Small` is a selection of `SmallString`. Its function is to encapsulate path selections. See the
/// `path()` function implemented by the `FromSmall` trait.
#[derive(Clone, Debug)]
pub struct Small<'a> {
    pub small:     &'a SmallString,

    // reduction holds a vec of slices into small.
    //
    //  name:         "Frodo Baggins"
    //  age:          "98"
    //  friends:
    //      hobbit:                     <----          
    //          name: "Bilbo Baggins"        slice1 <-- vec[0]
    //          age:  "176"             <----
    //      hobbit:                     <----
    //          name: "Samwise Gamgee"       slice2 <-- vec[1]
    //          age:  "66""#;           <----           
    //
    reduction:  Vec<&'a [Token]>,
}

impl<'a> Small<'a> {

    fn tokens(&self) -> Vec<String> {
        let mut v = Vec::new();

        for key_set in self.reduction.iter() {
            for token in key_set.iter() {
                v.push(token.to_string())
            }
        }
        v
    }

    // Applies a key to Small, returning a subset of Self. If the key cannot be found, the
    // result will be empty. Iterates through Small once. 
    fn apply_key(self, key: &str) -> Result<Small<'a>, SmallError> {
        let mut reduction: Vec<&[Token]> = Vec::new();

        for &slice in self.reduction.iter() {
            let root_indent = slice[0].indentation();
            let mut i = 0usize;
            'outer: loop {
                if slice[i].key() == key && (slice[i].indentation() - root_indent) / INDENTSTEP == 1 {
                    let start_index = i;
                    'inner: loop {

                        // Process the case where the slice is not the last token and the next
                        // token is a different key.
                        if (i < slice.len() - 1) &&
                           ((slice[i + 1].indentation() - root_indent) / INDENTSTEP <= 1) {
                            let end_index = i;
                            reduction.push(&slice[start_index..=end_index]);
                            break 'inner;
                        }

                        // Process the case where the slice in the last token.
                        if i == slice.len() - 1 {
                            let end_index = i;
                            reduction.push(&slice[start_index..=end_index]);
                            break 'outer;
                        };

                        i += 1
                    }
                };
                i += 1;
                if i == slice.len() { break 'outer };
            };
        };
        Ok(Small {
            small:      self.small,
            reduction:  reduction, 
        })
    }

    // Applies a path of keys to Small, returning a subset of Self. If the key cannot be found,
    // the result will be empty.
    fn apply_path(&self, s: &str) -> Result<Small, SmallError> {
        let mut reduction = self.clone();
        for (i, key) in KeyPath::from_str(s)?.enumerate() {
            if i > 0 {
                reduction = reduction.apply_key(&key.to_string())?;
            };
        }
        Ok(reduction)
    }
}

impl<'a> Display for Small<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut s = String::new();
        s.push_str("reductions:\n");
        for slice in self.reduction.iter() {
            s.push_str("[\n");
            for token in slice.iter() {
                s.push_str(&token.to_string());
                s.push('\n');
            }
            s.push_str("]\n");
        }
        s.pop();
        write!(f, "{}", s)
    }
}

impl<'a> Small<'a> {
    /// Checks that there is only one value in `Small` and returns it.
    pub fn unique_value(&self) -> Result<Token, SmallError> {
        if  self.reduction.is_empty() { return Err(SmallError::MissingToken) };
        if self.reduction.len() > 1 { return Err(SmallError::NotUnique(self.reduction.len())) };
        let token = &self.reduction[0][0];
        if token.is_value() { Ok(token.clone()) } else { Err(SmallError::IsKey(token.clone())) }
    }
}

/// Types that implement the `FromSmall` trait can be constructed from a `Small`-formatted string.
pub trait FromSmall {

    /// The `from_small()` function describes how to create a data-structure from the parts of
    /// `Small`. See example 1 for canonical usage.
    fn from_small(slice: &Small) -> Result<Self, SmallError>
        where Self: std::marker::Sized;

    /// Reduces `Small` to the `key_path` and then uses the `FromSmall` trait to convert to the
    /// receiver type.
    fn path(small: &Small, key_path: &str) -> Result<Self, SmallError>
    where
        Self: std::marker::Sized
    {
        Ok(Self::from_small(&small.apply_path(key_path)?)?)
    }

    /// Top level function that converts a `Small`-formatted string into the receiver.
    fn from_str(s: &str) -> Result<Self, SmallError>
        where Self: std::marker::Sized
    {
        let small = SmallString::from_str(s)?;
        let small = Small {
            small: &small,
            reduction: vec!(&small.0[..]),
        };
        Ok(Self::from_small(&small)?)
    }

    /// Top level function that converts a `SmallString`-formatted string into the receiver giving
    /// helpful error messages for debugging.
    fn from_str_debug(s: &str) -> Self
        where Self: std::marker::Sized
    {
        match Self::from_str(s) {
            Ok(s) => s,
            Err(e) => {
                match e {

                    SmallError::Empty => {
                        eprintln!("The input data string is empty.");
                    }

                    SmallError::EmptyKey(token, pos) => {
                        let info = &format!(
                            "{}{} {}",
                            " ".repeat(pos),
                            "^".yellow().bold(),
                            "missing key".yellow().bold(),
                        );
                        in_context(s, info, token.line);
                    },

                    SmallError::Indent(token, _) => {

                        let info = &format!(
                            "{}{}{}{} {} {} {}",
                            " ".repeat(token.start_key.unwrap() - 4 - (token.start_key.unwrap() % 4)),
                            "|".yellow().bold(),
                            "_".repeat(3).yellow().bold(),
                            "|".yellow().bold(),
                            "indent".yellow().bold(),
                            INDENTSTEP.to_string().yellow().bold(),
                            "spaces only".yellow().bold()
                        );
                        in_context(s, info, token.line);
                    },

                    SmallError::NoColon(token, pos) => {
                        let info = &format!(
                            "{}{} {}",
                            " ".repeat(token.start_key.unwrap()),
                            "^".repeat(pos - token.start_key.unwrap()).yellow().bold(),
                            "key requires colon".yellow().bold()
                        );
                        in_context(s, info, token.line);
                    },

                    SmallError::NoSecondQuote(token, pos) => {
                        let info = &format!(
                            "{}{} {}",
                            " ".repeat(pos),
                            "^".yellow().bold(),
                            "missing second quotemark".yellow().bold(),
                        );
                        in_context(s, info, token.line);
                    }

                    SmallError::NoSpaceAfterKey(token) => {
                        let info = &format!(
                            "{}{}{} {}",
                            " ".repeat(token.start_key.unwrap()),
                            " ".repeat(token.end_key.unwrap() + 1 - token.start_key.unwrap()),
                            "^".yellow().bold(),
                            "requires at least one space after key".yellow().bold()
                        );
                        in_context(s, info, token.line);
                    },

                    SmallError::ParseValue(token, to_type) => {
                        let info = &format!(
                               "{}{} {}",
                               " ".repeat(token.start_val.unwrap() + 1),
                               "^".repeat(token.value().unwrap().char_indices().count()).yellow().bold(),
                               format!("number could not be parsed into a {}", to_type).yellow().bold(), 
                        );
                        in_context(s, info, token.line);
                    },

                    SmallError::QuotemarkInKey(token, pos) => {
                        let info = &format!(
                            "{}{} {}",
                            " ".repeat(pos),
                            "^".yellow().bold(),
                            "no double quotes allowed in key".yellow().bold(),
                        );
                        in_context(s, info, token.line);
                    }

                    _ => eprintln!("{}", e.to_string()),
                };
                exit(1);
            },
        }
    }
}

fn in_context(s: &str, info: &str, line: usize) {
    for (i, ln) in s.lines().take(20).enumerate() {
        eprintln!("{}", ln);
        if i == line {
            eprintln!("{}", info);
        };
    };
}

impl FromSmall for String {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        small.unique_value()?.value()
    }
}

impl FromSmall for u8 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<u8>()
            .map_err(|_| SmallError::ParseValue(token, "u8"))
    }
}

impl FromSmall for i8 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<i8>()
            .map_err(|_| SmallError::ParseValue(token, "i8"))
    }
}

impl FromSmall for u16 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<u16>()
            .map_err(|_| SmallError::ParseValue(token, "u16"))
    }
}

impl FromSmall for i16 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<i16>()
            .map_err(|_| SmallError::ParseValue(token, "i16"))
    }
}

impl FromSmall for u32 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<u32>()
            .map_err(|_| SmallError::ParseValue(token, "u32"))
    }
}

impl FromSmall for i32 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<i32>()
            .map_err(|_| SmallError::ParseValue(token, "i32"))
    }
}

impl FromSmall for u64 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<u64>()
            .map_err(|_| SmallError::ParseValue(token, "u64"))
    }
}

impl FromSmall for i64 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<i64>()
            .map_err(|_| SmallError::ParseValue(token, "i64"))
    }
}

impl FromSmall for u128 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<u128>()
            .map_err(|_| SmallError::ParseValue(token, "u128"))
    }
}

impl FromSmall for i128 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<i128>()
            .map_err(|_| SmallError::ParseValue(token, "i128"))
    }
}

impl FromSmall for usize {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token.
            value()?
            .parse::<usize>()
            .map_err(|_| SmallError::ParseValue(token, "usize"))
    }
}

impl FromSmall for isize {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token.
            value()?
            .parse::<isize>()
            .map_err(|_| SmallError::ParseValue(token, "isize"))
    }
}

impl FromSmall for f32 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<f32>()
            .map_err(|_| SmallError::ParseValue(token, "f32"))
    }
}

impl FromSmall for f64 {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        token
            .value()?
            .parse::<f64>()
            .map_err(|_| SmallError::ParseValue(token, "f64"))
    }
}

impl FromSmall for bool {
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        let token = small.unique_value()?;
        if "false" == &token.value()? {
            return Ok(false)
        };
        if "true" == &token.value()? {
            return Ok(true)
        };
        Err(SmallError::ParseValue(token, "bool"))
    }
}

/// Converts a `Vec` with either one or no `Small` elements to an `Option<T>`. See Example 1 for
/// details.
impl<T> FromSmall for Option<T>
where
    T: FromSmall
{
    fn from_small(small: &Small) -> Result<Self, SmallError> {
        if small.reduction.is_empty() {
            return Ok(None)
        } else {
            Ok(Some(T::from_small(small)?))
        }
    }
}

impl<T>FromSmall for Vec<T>
where
    T: FromSmall
{
    fn from_small(s: &Small) -> Result<Self, SmallError> {
        let mut v: Vec<T> = Vec::new();
        for &slice in s.reduction.iter() {
            let dat = Small {
                small: s.small,
                reduction: vec!(slice),
            };
            v.push(T::from_small(&dat)?);
        };
        Ok(v)
    }
}