fn error_kind_msg()

in guard/src/rules/errors.rs [17:85]

• 53 lines of code
• 1 McCabe index (conditional complexity)

fn error_kind_msg(kind: &ErrorKind) -> String {
    match kind {
        ErrorKind::JsonError(err) => {
            format!("Error parsing incoming JSON context {}", err)
        },

        ErrorKind::YamlError(err) => {
            format!("Error parsing incoming YAML context {}", err)
        },

        ErrorKind::FormatError(fmt) => {
            format!("Formatting error when writing {}", fmt)
        },


        ErrorKind::IoError(io) => {
            format!("I/O error when reading {}", io)
        },

        ErrorKind::ParseError(err) => {
            format!("Parser Error when parsing {}", err)
        },

        ErrorKind::RegexError(err) => {
            format!("Regex expression parse error for rules file {}", err)
        },

        ErrorKind::MissingProperty(err) => {
            format!("Could not evaluate clause for a rule with missing property for incoming context {}", err)
        },

        ErrorKind::MissingVariable(err) => {
            format!("Variable assignment could not be resolved in rule file or incoming context {}", err)
        },

        ErrorKind::MultipleValues(err) => {
            format!("Conflicting rule or variable assignments inside the same scope {}", err)
        },

        ErrorKind::IncompatibleRetrievalError(err) => {
            format!("Types or variable assignments have incompatible types to retrieve {}", err)
        },

        ErrorKind::IncompatibleError(err) => {
            format!("Types or variable assignments are incompatible {}", err)
        },

        ErrorKind::NotComparable(err) => {
            format!("Comparing incoming context with literals or dynamic results wasn't possible {}", err)
        },

        ErrorKind::ConversionError(_ignore) => {
            format!("Could not convert in JSON value object")
        },

        ErrorKind::Errors(all) => {
            let vec = all.iter().map(|e| error_kind_msg(e) ).collect::<Vec<String>>();
            format!("{:?}", &vec)
        },

        ErrorKind::RetrievalError(err) => {
            format!("Could not retrieve data from incoming context. Error = {}", err)
        },

        ErrorKind::MissingValue(err) => {
            format!("There was no variable or value object to resolve. Error = {}", err)
        }
    }
}