variable_core/

validate.rs

#![allow(unused_assignments)]

use std::collections::HashMap;

use miette::{Diagnostic, SourceSpan};
use thiserror::Error;

use crate::ast::VarFile;
use crate::lexer::Span;

#[derive(Error, Debug, Diagnostic)]
pub enum ValidationError {
    #[error("duplicate feature name: `{name}`")]
    DuplicateFeature {
        name: String,
        #[label("first defined here")]
        first: SourceSpan,
        #[label("duplicate defined here")]
        duplicate: SourceSpan,
    },

    #[error("duplicate feature id `{id}`")]
    DuplicateFeatureId {
        id: u32,
        #[label("first defined here")]
        first: SourceSpan,
        #[label("duplicate defined here")]
        duplicate: SourceSpan,
    },

    #[error("duplicate variable name `{name}` in feature `{feature}`")]
    DuplicateVariable {
        feature: String,
        name: String,
        #[label("first defined here")]
        first: SourceSpan,
        #[label("duplicate defined here")]
        duplicate: SourceSpan,
    },

    #[error("duplicate variable id `{id}` in feature `{feature}`")]
    DuplicateVariableId {
        feature: String,
        id: u32,
        #[label("first defined here")]
        first: SourceSpan,
        #[label("duplicate defined here")]
        duplicate: SourceSpan,
    },
}

fn span_to_source_span(span: &Span) -> SourceSpan {
    SourceSpan::from(span.offset)
}

pub fn validate(var_file: &VarFile) -> Result<(), Vec<ValidationError>> {
    let mut errors = Vec::new();

    // Check for duplicate feature names and IDs
    let mut feature_names: HashMap<&str, &Span> = HashMap::new();
    let mut feature_ids: HashMap<u32, &Span> = HashMap::new();
    for feature in &var_file.features {
        if let Some(first_span) = feature_names.get(feature.name.as_str()) {
            errors.push(ValidationError::DuplicateFeature {
                name: feature.name.clone(),
                first: span_to_source_span(first_span),
                duplicate: span_to_source_span(&feature.span),
            });
        } else {
            feature_names.insert(&feature.name, &feature.span);
        }

        if let Some(first_span) = feature_ids.get(&feature.id) {
            errors.push(ValidationError::DuplicateFeatureId {
                id: feature.id,
                first: span_to_source_span(first_span),
                duplicate: span_to_source_span(&feature.span),
            });
        } else {
            feature_ids.insert(feature.id, &feature.span);
        }
    }

    // Check for duplicate variable names and IDs within each feature
    for feature in &var_file.features {
        let mut var_names: HashMap<&str, &Span> = HashMap::new();
        let mut var_ids: HashMap<u32, &Span> = HashMap::new();
        for variable in &feature.variables {
            if let Some(first_span) = var_names.get(variable.name.as_str()) {
                errors.push(ValidationError::DuplicateVariable {
                    feature: feature.name.clone(),
                    name: variable.name.clone(),
                    first: span_to_source_span(first_span),
                    duplicate: span_to_source_span(&variable.span),
                });
            } else {
                var_names.insert(&variable.name, &variable.span);
            }

            if let Some(first_span) = var_ids.get(&variable.id) {
                errors.push(ValidationError::DuplicateVariableId {
                    feature: feature.name.clone(),
                    id: variable.id,
                    first: span_to_source_span(first_span),
                    duplicate: span_to_source_span(&variable.span),
                });
            } else {
                var_ids.insert(variable.id, &variable.span);
            }
        }
    }

    if errors.is_empty() {
        Ok(())
    } else {
        Err(errors)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::lexer::lex;
    use crate::parser::parse;

    fn parse_and_validate(input: &str) -> Result<VarFile, Vec<ValidationError>> {
        let tokens = lex(input).expect("lex failed");
        let var_file = parse(tokens).expect("parse failed");
        validate(&var_file)?;
        Ok(var_file)
    }

    #[test]
    fn valid_file_passes() {
        let input = r#"1: Feature Checkout = {
    1: Variable enabled Boolean = true
    2: Variable max_items Number = 50
}

2: Feature Search = {
    1: Variable query String = "default"
}"#;
        assert!(parse_and_validate(input).is_ok());
    }

    #[test]
    fn duplicate_feature_name_error() {
        let input = r#"1: Feature Checkout = {
    1: Variable enabled Boolean = true
}

2: Feature Checkout = {
    1: Variable max_items Number = 50
}"#;
        let err = parse_and_validate(input).unwrap_err();
        assert_eq!(err.len(), 1);
        match &err[0] {
            ValidationError::DuplicateFeature { name, .. } => {
                assert_eq!(name, "Checkout");
            }
            _ => panic!("expected DuplicateFeature error"),
        }
    }

    #[test]
    fn duplicate_variable_name_error() {
        let input = r#"1: Feature Checkout = {
    1: Variable enabled Boolean = true
    2: Variable enabled Boolean = false
}"#;
        let err = parse_and_validate(input).unwrap_err();
        assert_eq!(err.len(), 1);
        match &err[0] {
            ValidationError::DuplicateVariable { feature, name, .. } => {
                assert_eq!(feature, "Checkout");
                assert_eq!(name, "enabled");
            }
            _ => panic!("expected DuplicateVariable error"),
        }
    }

    #[test]
    fn error_has_correct_line_info() {
        let input = r#"1: Feature Checkout = {
    1: Variable enabled Boolean = true
}

2: Feature Checkout = {
    1: Variable max_items Number = 50
}"#;
        let err = parse_and_validate(input).unwrap_err();
        match &err[0] {
            ValidationError::DuplicateFeature {
                first, duplicate, ..
            } => {
                // First "Feature" is at offset 0
                assert_eq!(first.offset(), 0);
                // Duplicate "Feature" is on line 5
                assert!(duplicate.offset() > 0);
            }
            _ => panic!("expected DuplicateFeature error"),
        }
    }

    #[test]
    fn duplicate_feature_id_error() {
        let input = r#"1: Feature Checkout = {
    1: Variable enabled Boolean = true
}

1: Feature Search = {
    1: Variable query String = "default"
}"#;
        let err = parse_and_validate(input).unwrap_err();
        assert_eq!(err.len(), 1);
        match &err[0] {
            ValidationError::DuplicateFeatureId { id, .. } => {
                assert_eq!(*id, 1);
            }
            _ => panic!("expected DuplicateFeatureId error"),
        }
    }

    #[test]
    fn duplicate_variable_id_error() {
        let input = r#"1: Feature Checkout = {
    1: Variable enabled Boolean = true
    1: Variable max_items Number = 50
}"#;
        let err = parse_and_validate(input).unwrap_err();
        assert_eq!(err.len(), 1);
        match &err[0] {
            ValidationError::DuplicateVariableId { feature, id, .. } => {
                assert_eq!(feature, "Checkout");
                assert_eq!(*id, 1);
            }
            _ => panic!("expected DuplicateVariableId error"),
        }
    }
}