feat: implement comparison skeleton

This commit lays out the general idea of how the ComparisonData struct will work. It is expandable and I'm sure we will add more to it as time goes on.

src/common/comparison/base.rs

@@ -0,0 +1,91 @@
+use super::{
+    Comparison, MapListComparison, NestedListComparison, NumberComparison, NumberListComparison,
+    TextComparison, TextListComparison,
+};
+use crate::common::{ExpandableInfo, ValueType};
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct ComparisonData {
+    /// Each comparison will have a unique ID.
+    pub id: String,
+    /// The member from the Student structure to match against.
+    pub member: String,
+    /// The comparison to perform.
+    pub comparison: ComparisonType,
+    /// The value to match against.
+    pub target_value: ValueType,
+    /// The display category for this comparison. Affects where this comparison
+    /// will be displayed in the provider side of the application.
+    pub category: String,
+    /// The text that will be displayed on the provider side.
+    pub display_text: String,
+}
+
+impl ComparisonData {
+    pub fn compare(&self, student_data: &ExpandableInfo) -> Result<bool, String> {
+        let value = student_data.data.get(&self.member).unwrap();
+        self.comparison.evaluate(value, &self.target_value)
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub enum ComparisonType {
+    Number(NumberComparison),
+    Text(TextComparison),
+    TextList(TextListComparison),
+    NumberList(NumberListComparison),
+    MapList(MapListComparison),
+    NestedList(NestedListComparison),
+}
+
+impl Comparison for ComparisonType {
+    fn evaluate(&self, comp_value: &ValueType, target_value: &ValueType) -> Result<bool, String> {
+        match self {
+            ComparisonType::Number(n) => n.evaluate(comp_value, target_value),
+            ComparisonType::Text(t) => t.evaluate(comp_value, target_value),
+            ComparisonType::NumberList(l) => l.evaluate(comp_value, target_value),
+            ComparisonType::MapList(m) => m.evaluate(comp_value, target_value),
+            ComparisonType::TextList(tl) => tl.evaluate(comp_value, target_value),
+            ComparisonType::NestedList(nl) => nl.evaluate(comp_value, target_value),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::common::comparison::test_utils::create_student_data;
+    use super::*;
+    
+    #[test]
+    fn test_student_data() {
+        let student_data = create_student_data();
+        
+        // Should succeed every time.
+        let text_comp_success = ComparisonData {
+            id: "first_name_success".to_string(),
+            member: "first_name".to_string(),
+            comparison: ComparisonType::Text(TextComparison::Matches),
+            target_value: ValueType::String(Some("John".to_string())),
+            category: "Basic Checks".to_string(),
+            display_text: "First Name is John".to_string(),
+        };
+
+        // Uses an incorrect target_value type.
+        let text_comp_fail = ComparisonData {
+            id: "first_name_fail".to_string(),
+            member: "first_name".to_string(),
+            comparison: ComparisonType::Text(TextComparison::Matches),
+            target_value: ValueType::Number(Some("Jane".to_string())),
+            category: "Basic Checks".to_string(),
+            display_text: "First Name is Jane".to_string(),
+        };
+        
+        let mut result = text_comp_success.compare(&student_data);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+        
+        result = text_comp_fail.compare(&student_data);
+        assert!(result.is_err());
+    }
+}

src/common/comparison/lists.rs

@@ -0,0 +1,477 @@
+use super::{Comparison, NumberComparison};
+use crate::common::ValueType;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub enum NumberListComparison {
+    /// Sums the values in the list and checks them using the given [`NumberComparison`].
+    /// Requires the list to contain only numbers.
+    Sum(Box<NumberComparison>),
+    /// Checks if the list contains a specific value.
+    Contains,
+    /// Checks if the list does not contain a specific value.
+    NotContains,
+}
+
+impl Comparison for NumberListComparison {
+    fn evaluate(&self, comp_value: &ValueType, target_value: &ValueType) -> Result<bool, String> {
+        match self {
+            NumberListComparison::Sum(num_comp) => {
+                // Requires the list to contain only numbers. Get this list or throw an error.
+                let student_list = match comp_value {
+                    ValueType::List(Some(list)) => list,
+                    _ => return Err("Expected a list".into()),
+                };
+
+                let sum = student_list.iter().try_fold(0.0, |acc, item| match item {
+                    ValueType::Number(Some(num_str)) => {
+                        let num = num_str.parse::<f64>().unwrap();
+                        Ok(acc + num)
+                    }
+                    _ => Err("Expected a number".into()),
+                });
+
+                // If the sum is not a number, return an error.
+                let sum = match sum {
+                    Ok(sum) => sum,
+                    Err(err) => return Err(err),
+                };
+
+                // Finally perform the comparison using this sum... we don't have a function for this yet.
+                match num_comp.evaluate(&ValueType::Number(Some(sum.to_string())), target_value) {
+                    Ok(result) => Ok(result),
+                    Err(err) => Err(err),
+                }
+            }
+            NumberListComparison::Contains => {
+                // Get list and check if it contains the target value.
+                // This will check the type and the value, in that order. If the type does not match,
+                // this will return false.
+                let list = match comp_value {
+                    ValueType::List(Some(vec)) => vec,
+                    _ => return Err("Expected a list".into()),
+                };
+
+                // Check if the list contains the target value.
+                Ok(list.contains(target_value))
+            }
+            _ => Err("Not implemented".into()),
+        }
+    }
+}
+
+/// Represents all available comparisons for a text list. All comparisons are comparable to a
+/// single value.
+/// 
+/// For example, using `TextListComparison::Contains` checks if a specific value is contained
+/// in the list.
+#[derive(Serialize, Deserialize, Debug)]
+pub enum TextListComparison {
+    /// Checks if the list contains the target value.
+    Contains,
+    /// Checks if the list does not contain the target value.
+    NotContains,
+    /// Checks if the list is empty.
+    IsEmpty,
+    /// Checks if the list is not empty.
+    IsNotEmpty,
+}
+
+impl Comparison for TextListComparison {
+    fn evaluate(&self, comp_value: &ValueType, target_value: &ValueType) -> Result<bool, String> {
+        match self {
+            TextListComparison::Contains => {
+                let list_opt = match comp_value {
+                    ValueType::List(list) => list,
+                    _ => return Err("Expected a list".into()),
+                };
+
+                // If the list exists, check if it contains the target value.
+                // Otherwise, return false. Note that this is not a strongly typed comparison - if
+                // the list contains multiple different types, no error is thrown.
+                let check = match list_opt {
+                    Some(list) => list.contains(target_value),
+                    None => false,
+                };
+
+                Ok(check)
+            }
+            TextListComparison::NotContains => {
+                let list_opt = match comp_value {
+                    ValueType::List(list) => list,
+                    _ => return Err("Expected a list".into()),
+                };
+
+                // If the list exists, check if it does not contain the target value.
+                // Otherwise, return true.
+                let check = match list_opt {
+                    Some(list) => !list.contains(target_value),
+                    None => true,
+                };
+
+                Ok(check)
+            }
+            TextListComparison::IsEmpty => {
+                let list_opt = match comp_value {
+                    ValueType::List(list) => list,
+                    _ => return Err("Expected a list".into()),
+                };
+
+                // If the list exists, check if it is empty.
+                // Otherwise, return false.
+                let check = match list_opt {
+                    Some(list) => list.is_empty(),
+                    None => true,
+                };
+
+                Ok(check)
+            }
+            TextListComparison::IsNotEmpty => {
+                let list_opt = match comp_value {
+                    ValueType::List(list) => list,
+                    _ => return Err("Expected a list".into()),
+                };
+
+                // If the list exists, check if it is not empty.
+                // Otherwise, return true.
+                let check = match list_opt {
+                    Some(list) => !list.is_empty(),
+                    None => false,
+                };
+
+                Ok(check)
+            }
+        }
+    }
+}
+
+/// For right now, nested lists should be flattened into a list of a single type before they
+/// are compared. The plan is to create a more robust framework that eventually be able to
+/// query specific lists and perform comparisons on them.
+/// 
+/// For example:
+/// ```
+/// NestedListComparison::FlattenToTextList(Box::new(TextListComparison::Contains));
+/// ```
+/// 
+/// This will flatten a nested list into a single list of `ValueType::String` enums and then
+/// will check if the list contains the indicated target value.
+#[derive(Serialize, Deserialize, Debug)]
+pub enum NestedListComparison {
+    /// Flattens a nested list into a single text list, then performs the given comparison.
+    FlattenToTextList(Box<TextListComparison>),
+}
+
+impl Comparison for NestedListComparison {
+    fn evaluate(&self, comp_value: &ValueType, target_value: &ValueType) -> Result<bool, String> {
+        match self {
+            NestedListComparison::FlattenToTextList(t) => {
+                // Check the comp_value for a series of lists. We'll then iterate over each list and flatten it to a text list.
+                // The end type should be a ValueType::List(Option<Vec<T>>), where T is ValueType::String.
+                let list = match comp_value {
+                    ValueType::List(Some(list)) => list,
+                    _ => return Err("Expected a list of values".to_owned()),
+                };
+
+                let mut out: Vec<ValueType> = Vec::new();
+
+                for item in list {
+                    // Every item should be another list.
+                    let sub_list = match item {
+                        ValueType::List(Some(sub_list)) => sub_list,
+                        _ => return Err("Expected a list of lists".to_owned()),
+                    };
+
+                    for sub_item in sub_list {
+                        match sub_item {
+                            s @ ValueType::String(_) => out.push(s.clone()),
+                            _ => return Err("Expected a list of strings".to_owned()),
+                        }
+                    }
+                }
+
+                t.evaluate(&ValueType::List(Some(out)), target_value)
+            }
+        }
+    }
+}
+
+/// Lists of maps must be flattened to a list of some type before they can be compared.
+/// Flattening maps simply extracts the values from a specific key from all maps in the list.
+/// This makes comparison much simpler to implement and understand.
+///
+/// All flattening operations also contain a `String` key (the map's member to flatten)
+/// and some `Comparison` enum that matches the type of the flattened values. Flattening will
+/// fail if any single map in the list does not contain the specified key or if the value
+/// is not of the expected type.
+///
+/// For example, to flatten a list of maps by using the `name` key, we would use the following
+/// structure:
+/// ```
+/// MapListComparison::FlattenToTextList("name".to_owned(), Box::new(TextListComparison::Equal));
+/// ```
+#[derive(Serialize, Deserialize, Debug)]
+pub enum MapListComparison {
+    /// Flattens the map list to a text list and then performs the given comparison.
+    FlattenToTextList(String, Box<TextListComparison>),
+    /// Flattens the map list to a number list and then performs the given comparison.
+    FlattenToNumberList(String, Box<NumberListComparison>),
+    /// Flattens the map list to a nested list and then performs the given comparison.
+    FlattenToNestedList(String, Box<NestedListComparison>),
+}
+
+impl Comparison for MapListComparison {
+    fn evaluate(&self, comp_value: &ValueType, target_value: &ValueType) -> Result<bool, String> {
+        // Define base list - this must be present otherwise we cannot proceed.
+        let list = match comp_value {
+            ValueType::List(Some(list)) => list,
+            ValueType::List(None) => &Vec::new(),
+            _ => return Err("Expected a list".to_owned()),
+        };
+
+        match self {
+            MapListComparison::FlattenToTextList(key, comp) => {
+                let mut out = Vec::new();
+
+                for item in list {
+                    let map = match item {
+                        ValueType::Map(Some(map)) => map,
+                        _ => return Err("Expected a map".to_string()),
+                    };
+
+                    // Ignore any non-string values.
+                    if let Some(text @ ValueType::String(_)) = map.get(key) {
+                        out.push(text.clone());
+                    }
+                }
+
+                let flattened = ValueType::List(Some(out));
+                comp.evaluate(&flattened, target_value)
+            }
+            MapListComparison::FlattenToNumberList(key, comp) => {
+                let mut out = Vec::new();
+                for item in list {
+                    let map = match item {
+                        ValueType::Map(Some(map)) => map,
+                        _ => return Err("Expected a map".to_string()),
+                    };
+
+                    // Ignore any non-number values.
+                    if let Some(number @ ValueType::Number(_)) = map.get(key) {
+                        out.push(number.clone());
+                    }
+                }
+
+                let flattened = ValueType::List(Some(out));
+                comp.evaluate(&flattened, target_value)
+            }
+            MapListComparison::FlattenToNestedList(key, comp) => {
+                let mut out = Vec::new();
+                for item in list {
+                    let map = match item {
+                        ValueType::Map(Some(map)) => map,
+                        _ => return Err("Expected a map".to_string()),
+                    };
+
+                    // Ignore any non-list values.
+                    if let Some(list @ ValueType::List(_)) = map.get(key) {
+                        out.push(list.clone());
+                    }
+                }
+
+                let flattened = ValueType::List(Some(out));
+                comp.evaluate(&flattened, target_value)
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use super::super::test_utils::{create_map_list_helper};
+    use crate::common::{ComparisonType};
+    use crate::common::comparison::test_utils::{create_empty_lists, create_number_list, create_text_list};
+
+    #[test]
+    fn map_list_flatten_to_text_list() {
+        let map_list = create_map_list_helper();
+
+        // Define our comparison, paying close attention to the target values.
+        let first_name_comp = ComparisonType::MapList(MapListComparison::FlattenToTextList(
+            "first_name".to_string(),
+            Box::new(TextListComparison::Contains),
+        ));
+
+        let last_name_comp = ComparisonType::MapList(MapListComparison::FlattenToTextList(
+            "last_name".to_string(),
+            Box::new(TextListComparison::Contains),
+        ));
+
+        let gender_comp = ComparisonType::MapList(MapListComparison::FlattenToTextList(
+            "gender".to_string(),
+            Box::new(TextListComparison::Contains),
+        ));
+
+        let first_name_result =
+            first_name_comp.evaluate(&map_list, &ValueType::String(Some("Jane".to_string())));
+        let last_name_result =
+            last_name_comp.evaluate(&map_list, &ValueType::String(Some("Fails".to_string())));
+        let gender_result =
+            gender_comp.evaluate(&map_list, &ValueType::String(Some("Female".to_string())));
+
+        // We have one map that contains the target value (map_two.first_name)
+        assert_eq!(first_name_result.unwrap(), true);
+        assert_eq!(last_name_result.unwrap(), false);
+        assert_eq!(gender_result.unwrap(), true);
+    }
+
+    #[test]
+    fn map_list_flatten_to_number_list() {
+        let map_list = create_map_list_helper();
+
+        let sum_comparison = ComparisonType::MapList(MapListComparison::FlattenToNumberList(
+            "sat_score".to_string(),
+            Box::new(NumberListComparison::Sum(Box::new(NumberComparison::Equal))),
+        ));
+
+        let result = sum_comparison.evaluate(&map_list, &ValueType::Number(Some(2200.to_string())));
+        let failed = sum_comparison.evaluate(&map_list, &ValueType::Number(Some(2201.to_string())));
+
+        assert_eq!(result.unwrap(), true);
+        assert_eq!(failed.unwrap(), false);
+    }
+
+    #[test]
+    fn map_list_flatten_to_nested_list() {
+        let map_list = create_map_list_helper();
+
+        let comparison = ComparisonType::MapList(MapListComparison::FlattenToNestedList(
+            "grades_participated".to_string(),
+            Box::new(NestedListComparison::FlattenToTextList(Box::new(
+                TextListComparison::Contains,
+            ))),
+        ));
+
+        let result = comparison.evaluate(&map_list, &ValueType::String(Some("9".to_string())));
+        let failed = comparison.evaluate(&map_list, &ValueType::String(Some("13".to_string())));
+
+        assert_eq!(result.unwrap(), true);
+        assert_eq!(failed.unwrap(), false);
+    }
+
+    #[test]
+    fn number_list_sum_comparison() {
+        let list = create_number_list();
+
+        let comparison = ComparisonType::NumberList(NumberListComparison::Sum(Box::new(
+            NumberComparison::Equal,
+        )));
+
+        let result = comparison.evaluate(&list, &ValueType::Number(Some(15.to_string())));
+
+        assert_eq!(result.unwrap(), true);
+    }
+
+    #[test]
+    fn number_list_contains_all_types() {
+        let num_list = create_number_list();
+
+        let string_list = ValueType::List(Some(vec![
+            ValueType::String(Some("a".to_string())),
+            ValueType::String(Some("b".to_string())),
+            ValueType::String(Some("c".to_string())),
+            ValueType::String(Some("d".to_string())),
+            ValueType::String(Some("e".to_string())),
+        ]));
+
+        let mixed_list = ValueType::List(Some(vec![
+            ValueType::Number(Some(1.to_string())),
+            ValueType::String(Some("b".to_string())),
+            ValueType::Number(Some(3.to_string())),
+            ValueType::String(Some("d".to_string())),
+            ValueType::Number(Some(5.to_string())),
+        ]));
+
+        let comparison = ComparisonType::NumberList(NumberListComparison::Contains);
+
+        let num_result = comparison.evaluate(&num_list, &ValueType::Number(Some(3.to_string())));
+        let string_result =
+            comparison.evaluate(&string_list, &ValueType::String(Some("a".to_string())));
+        let mixed_result =
+            comparison.evaluate(&mixed_list, &ValueType::String(Some("b".to_string())));
+
+        let incorrect_type =
+            comparison.evaluate(&string_list, &ValueType::Number(Some(1.to_string())));
+        let incorrect_value =
+            comparison.evaluate(&string_list, &ValueType::String(Some("f".to_string())));
+        let mixed_incorrect_type =
+            comparison.evaluate(&string_list, &ValueType::String(Some("1".to_string())));
+
+        assert_eq!(num_result.unwrap(), true);
+        assert_eq!(string_result.unwrap(), true);
+        assert_eq!(mixed_result.unwrap(), true);
+        assert_eq!(incorrect_type.unwrap(), false);
+        assert_eq!(incorrect_value.unwrap(), false);
+        assert_eq!(mixed_incorrect_type.unwrap(), false);
+    }
+    
+    #[test]
+    fn text_list_contains() {
+        let (none_list, empty_list) = create_empty_lists();
+        let num_list = create_number_list();
+        let text_list = create_text_list();
+        
+        // Define comparisons here
+        let comparison = ComparisonType::TextList(TextListComparison::Contains);
+        let target_value = ValueType::String(Some("one".to_string()));
+        
+        let none_result = comparison.evaluate(&none_list, &target_value);
+        let empty_result = comparison.evaluate(&empty_list, &target_value);
+        let num_result = comparison.evaluate(&num_list, &target_value);
+        let text_list = comparison.evaluate(&text_list, &target_value);
+        
+        assert_eq!(none_result.unwrap(), false);
+        assert_eq!(empty_result.unwrap(), false);
+        assert_eq!(num_result.unwrap(), false);
+        assert_eq!(text_list.unwrap(), true);
+    }
+    
+    #[test]
+    fn text_list_empty() {
+        let none_list = ValueType::List(None);
+        let empty_list = ValueType::List(Some(vec![]));
+        let long_list = ValueType::List(Some(vec![
+            ValueType::String(None),
+        ]));
+        
+        let empty_comp = ComparisonType::TextList(TextListComparison::IsEmpty);
+        let not_empty_comp = ComparisonType::TextList(TextListComparison::IsNotEmpty);
+        
+        // This comparison does not use a target value, as it should just check if the list
+        // either doesn't exist or is empty.
+        let mut result = empty_comp.evaluate(&empty_list, &ValueType::List(None));
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+        
+        result = empty_comp.evaluate(&none_list, &ValueType::List(None));
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+        
+        result = empty_comp.evaluate(&long_list, &ValueType::List(None));
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), false);
+        
+        result = not_empty_comp.evaluate(&empty_list, &ValueType::List(None));
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), false);
+        
+        result = not_empty_comp.evaluate(&none_list, &ValueType::List(None));
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), false);
+        
+        result = not_empty_comp.evaluate(&long_list, &ValueType::List(None));
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap(), true);
+    }
+}

src/common/comparison/mod.rs

@@ -0,0 +1,145 @@
+mod base;
+mod lists;
+mod number;
+mod text;
+mod traits;
+mod utils;
+
+pub use self::{base::*, lists::*, number::*, text::*, traits::*};
+
+#[cfg(test)]
+mod test_utils {
+    use std::collections::HashMap;
+    use crate::common::{ExpandableInfo, ValueType};
+
+    pub fn create_student_data() -> ExpandableInfo {
+        let map = create_map_helper(
+            vec![
+                "first_name".to_string(),
+                "last_name".to_string(),
+                "gender".to_string(),
+                "sat_score".to_string(),
+                "athletic_participation".to_string(),
+                "community_involvement".to_string(),
+            ],
+            vec![
+                ValueType::String(Some("John".to_string())),
+                ValueType::String(Some("Doe".to_string())),
+                ValueType::String(Some("Male".to_string())),
+                ValueType::Number(Some(1190.to_string())),
+                ValueType::Map(Some(create_map_helper(
+                    vec![
+                        "sport_name".to_string(),
+                        "grades_participated".to_string(),
+                        "special_achievement".to_string(),
+                    ],
+                    vec![
+                        ValueType::String(Some("Football".to_string())),
+                        ValueType::List(Some(vec![
+                            ValueType::String(Some(9.to_string())),
+                            ValueType::String(Some(10.to_string())),
+                        ])),
+                        ValueType::String(Some("N/A".to_string())),
+                    ]
+                ))),
+                ValueType::Map(Some(create_map_helper(
+                    vec![
+                        "activity_name".to_string(),
+                        "total_hours".to_string(),
+                    ],
+                    vec![
+                        ValueType::String(Some("Raking".to_string())),
+                        ValueType::Number(Some(30.to_string())),
+                    ]
+                ))),
+            ]
+        );
+
+        let mut info = ExpandableInfo::new("test");
+        info.data = map;
+
+        info
+    }
+
+    pub fn create_map_helper(keys: Vec<String>, values: Vec<ValueType>) -> HashMap<String, ValueType> {
+        keys
+            .iter()
+            .cloned()
+            .zip(values.iter().cloned())
+            .collect::<HashMap<String, ValueType>>()
+    }
+
+    pub fn create_map_list_helper() -> ValueType {
+        let map_one = create_map_helper(
+            vec![
+                "first_name".to_string(),
+                "last_name".to_string(),
+                "gender".to_string(),
+                "sat_score".to_string(),
+                "grades_participated".to_string()
+            ],
+            vec![
+                ValueType::String(Some("John".to_string())),
+                ValueType::String(Some("Doe".to_string())),
+                ValueType::String(Some("Male".to_string())),
+                ValueType::Number(Some(1200.to_string())),
+                ValueType::List(Some(vec![
+                    ValueType::String(Some("9".to_string())),
+                    ValueType::String(Some("10".to_string()))
+                ]))
+            ],
+        );
+
+        let map_two = create_map_helper(
+            vec![
+                "first_name".to_string(),
+                "last_name".to_string(),
+                "gender".to_string(),
+                "sat_score".to_string(),
+                "grades_participated".to_string()
+            ],
+            vec![
+                ValueType::String(Some("Jane".to_string())),
+                ValueType::String(Some("Doe".to_string())),
+                ValueType::String(Some("Female".to_string())),
+                ValueType::Number(Some(1000.to_string())),
+                ValueType::List(Some(vec![
+                    ValueType::String(Some("11".to_string())),
+                    ValueType::String(Some("12".to_string()))
+                ]))
+            ],
+        );
+
+        ValueType::List(Some(vec![
+            ValueType::Map(Some(map_one)),
+            ValueType::Map(Some(map_two)),
+        ]))
+    }
+    
+    pub fn create_empty_lists() -> (ValueType, ValueType) {
+        let none_list = ValueType::List(None);
+        let empty_list = ValueType::List(Some(vec![]));
+        
+        (none_list, empty_list)
+    }
+    
+    pub fn create_number_list() -> ValueType {
+        ValueType::List(Some(vec![
+            ValueType::Number(Some(1.to_string())),
+            ValueType::Number(Some(2.to_string())),
+            ValueType::Number(Some(3.to_string())),
+            ValueType::Number(Some(4.to_string())),
+            ValueType::Number(Some(5.to_string())),
+        ]))
+    }
+    
+    pub fn create_text_list() -> ValueType {
+        ValueType::List(Some(vec![
+            ValueType::String(Some("one".to_string())),
+            ValueType::String(Some("two".to_string())),
+            ValueType::String(Some("three".to_string())),
+            ValueType::String(Some("four".to_string())),
+            ValueType::String(Some("five".to_string())),
+        ]))
+    }
+}

src/common/comparison/number.rs

@@ -0,0 +1,44 @@
+use super::Comparison;
+use crate::common::ValueType;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub enum NumberComparison {
+    GreaterThan,
+    LessThan,
+    Equal,
+    NotEqual,
+    GreaterThanOrEqual,
+    LessThanOrEqual,
+}
+
+impl Comparison for NumberComparison {
+    fn evaluate(&self, comp_value: &ValueType, target_value: &ValueType) -> Result<bool, String> {
+        // The prerequisites for all number comparisons is that the target value is Some(number) and the
+        // comparison member points to Some(number) in the student_info.
+        let student_value = match comp_value {
+            ValueType::Number(Some(num)) => num.parse::<i32>().unwrap(),
+            _ => {
+                return Err("Student value is not a number".into());
+            }
+        };
+
+        let target = match target_value {
+            ValueType::Number(Some(num)) => num.parse::<i32>().unwrap(),
+            _ => {
+                return Err("Target value is not a number".into());
+            }
+        };
+
+        let matched = match self {
+            NumberComparison::GreaterThan => student_value > target,
+            NumberComparison::LessThan => student_value < target,
+            NumberComparison::Equal => student_value == target,
+            NumberComparison::NotEqual => student_value != target,
+            NumberComparison::GreaterThanOrEqual => student_value >= target,
+            NumberComparison::LessThanOrEqual => student_value <= target,
+        };
+
+        Ok(matched)
+    }
+}

src/common/comparison/text.rs

@@ -0,0 +1,36 @@
+use super::Comparison;
+use crate::common::ValueType;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug)]
+pub enum TextComparison {
+    Matches,
+    NotMatches,
+    Contains,
+    NotContains,
+}
+
+impl Comparison for TextComparison {
+    fn evaluate(&self, comp_value: &ValueType, target_value: &ValueType) -> Result<bool, String> {
+        // All text comparisons require that the comp.member points to a Some(string) in the student_info,
+        // and that the target_value is also a Some(string).
+        let student_value = match comp_value {
+            ValueType::String(Some(value)) => value,
+            _ => return Err("Student value is not a string".into()),
+        };
+
+        let target_value = match target_value {
+            ValueType::String(Some(value)) => value,
+            _ => return Err("Target value is not a string".into()),
+        };
+
+        let matched = match self {
+            TextComparison::Matches => student_value == target_value,
+            TextComparison::NotMatches => student_value != target_value,
+            TextComparison::Contains => student_value.contains(target_value),
+            TextComparison::NotContains => !student_value.contains(target_value),
+        };
+
+        Ok(matched)
+    }
+}

src/common/comparison/traits.rs

@@ -0,0 +1,5 @@
+use crate::common::ValueType;
+
+pub trait Comparison {
+    fn evaluate(&self, comp_value: &ValueType, target_value: &ValueType) -> Result<bool, String>;
+}

src/common/comparison/utils.rs

@@ -0,0 +1,28 @@
+use crate::common::ValueType;
+
+/// This function is a work in progress. It's designed to flatten a list of maps by using the
+/// given key and verifier function, however it currently doesn't work and just needs to be
+/// planned out a little more.
+fn flatten_map_helper<F>(
+    list: &Vec<ValueType>,
+    key: &String,
+    verifier: F,
+) -> Result<Vec<ValueType>, String>
+where
+    F: Fn(&ValueType) -> Option<&ValueType>,
+{
+    let mut out = Vec::new();
+    for item in list {
+        let map = match item {
+            ValueType::Map(Some(map)) => map,
+            _ => return Err("Expected a map".to_owned()),
+        };
+
+        // Get the key, and verify that the value is the correct type. If so, push it.
+        if let Some(value) = map.get(key).and_then(|v| verifier(v)) {
+            out.push(value.clone());
+        }
+    }
+
+    Ok(out)
+}

src/common/expandable_info.rs

@@ -25,9 +25,9 @@ pub struct ExpandableInfo {
 }
 
 impl ExpandableInfo {
-    pub fn new(key: String) -> Self {
+    pub fn new(key: impl Into<String>) -> Self {
         Self {
-            subject: key,
+            subject: key.into(),
             data: HashMap::new(),
         }
     }

src/common/mod.rs

@@ -1,6 +1,7 @@
+mod comparison;
 mod expandable_info;
 mod form_schema;
 mod user;
-pub mod value_type;
+mod value_type;
 
-pub use self::{expandable_info::*, form_schema::*, user::*, value_type::*};
+pub use self::{comparison::*, expandable_info::*, form_schema::*, user::*, value_type::*};