fn evaluate Result()

in guard/src/rules/evaluate.rs [724:768]
41 lines of code
8 McCabe index (conditional complexity)

    fn evaluate<'s>(&self, context: &'s PathAwareValue, var_resolver: &'s dyn EvaluationContext) -> Result<Status> {
        let blk_context = format!("Block[{}]", self.location);
        let mut report = AutoReport::new(
            EvaluationType::BlockClause,
            var_resolver,
            &blk_context
        );
        let all = self.query.match_all;
        let block_values = match resolve_query(all, &self.query.query, context, var_resolver) {
            Err(Error(ErrorKind::RetrievalError(e))) |
            Err(Error(ErrorKind::IncompatibleRetrievalError(e))) => {
                return Ok(report.message(e).status(Status::FAIL).get_status())
            },

            Ok(v) => if v.is_empty() { // one or more
                return Ok(report.from(Some(context.clone())).message(format!("Query {} returned no results", SliceDisplay(&self.query.query))).status(Status::FAIL)
                    .get_status())
            } else { v },

            Err(e) => return Err(e)
        };

        Ok(report.status(loop {
            let mut num_fail = 0;
            let mut num_pass = 0;
            for each in block_values {
                match self.block.evaluate(each, var_resolver)? {
                    Status::FAIL => { num_fail += 1; },
                    Status::SKIP => {},
                    Status::PASS => { num_pass += 1; }
                }
            }

            if all {
                if num_fail > 0 { break Status::FAIL }
                if num_pass > 0 { break Status::PASS }
                break Status::SKIP
            }
            else {
                if num_pass > 0 { break Status::PASS }
                if num_fail > 0 { break Status::FAIL }
                break Status::SKIP
            }
        }).get_status())
    }