fn eq()

in guard/src/rules/path_value.rs [147:194]
41 lines of code
3 McCabe index (conditional complexity)

    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (PathAwareValue::Map((_, map)), PathAwareValue::Map((_, map2))) => map == map2,

            (PathAwareValue::List((_, list)), PathAwareValue::List((_, list2))) => list == list2,

            (PathAwareValue::Bool((_, b1)), PathAwareValue::Bool((_, b2))) => b1 == b2,

            (PathAwareValue::String((_, s)), PathAwareValue::Regex((_, r))) => {
                if let Ok(regex) = regex::Regex::new(r.as_str()) {
                    regex.is_match(s.as_str())
                } else {
                    false
                }
            },
            (PathAwareValue::Regex((_, r)), PathAwareValue::String((_, s))) =>  {
                if let Ok(regex) = regex::Regex::new(r.as_str()) {
                    regex.is_match(s.as_str())
                } else {
                    false
                }
            },
            (PathAwareValue::Regex((_, r)), PathAwareValue::Regex((_, s))) => r == s,

            //
            // Range checks
            //
            (PathAwareValue::Int((_, value)), PathAwareValue::RangeInt((_, r))) => {
                value.is_within(r)
            },

            (PathAwareValue::Float((_, value)), PathAwareValue::RangeFloat((_, r))) => {
                value.is_within(r)
            },

            (PathAwareValue::Char((_, value)), PathAwareValue::RangeChar((_, r))) => {
                value.is_within(r)
            },

            (rest, rest2) => match compare_values(rest, rest2) {
                    Ok(ordering) => match ordering {
                        Ordering::Equal => true,
                        _ => false
                    },
                    Err(_) => false
                }
        }
    }