private InvokeResult ProcessTargetObject()

in src/PSRule/Pipeline/InvokeRulePipeline.cs [238:327]
71 lines of code
19 McCabe index (conditional complexity)

        private InvokeResult ProcessTargetObject(TargetObject targetObject)
        {
            try
            {
                Context.EnterTargetObject(targetObject);
                var result = new InvokeResult();
                var ruleCounter = 0;
                var suppressedRuleCounter = 0;
                var suppressionGroupCounter = new Dictionary<string, int>();

                // Process rule blocks ordered by dependency graph
                foreach (var ruleBlockTarget in _RuleGraph.GetSingleTarget())
                {
                    // Enter rule block scope
                    var ruleRecord = Context.EnterRuleBlock(ruleBlock: ruleBlockTarget.Value);
                    ruleCounter++;

                    try
                    {
                        if (Context.Binding.ShouldFilter)
                            continue;

                        // Check if dependency failed
                        if (ruleBlockTarget.Skipped)
                        {
                            ruleRecord.OutcomeReason = RuleOutcomeReason.DependencyFail;
                        }
                        // Check for suppression
                        else if (_SuppressionFilter.Match(id: ruleBlockTarget.Value.Id, targetName: ruleRecord.TargetName))
                        {
                            ruleRecord.OutcomeReason = RuleOutcomeReason.Suppressed;
                            suppressedRuleCounter++;

                            if (_ResultFormat == ResultFormat.Detail)
                                Context.WarnRuleSuppressed(ruleId: ruleRecord.RuleId);
                        }
                        // Check for suppression group
                        else if (_SuppressionGroupFilter.TrySuppressionGroup(ruleId: ruleRecord.RuleId, targetObject, out var suppressionGroupId))
                        {
                            ruleRecord.OutcomeReason = RuleOutcomeReason.Suppressed;

                            if (_ResultFormat == ResultFormat.Detail)
                                Context.WarnRuleSuppressionGroup(ruleId: ruleRecord.RuleId, suppressionGroupId);

                            else if (_ResultFormat == ResultFormat.Summary)
                                suppressionGroupCounter[suppressionGroupId] = suppressionGroupCounter.TryGetValue(suppressionGroupId, out var count) ? ++count : 1;
                        }
                        else
                        {
                            HostHelper.InvokeRuleBlock(context: Context, ruleBlock: ruleBlockTarget.Value, ruleRecord: ruleRecord);
                            if (ruleRecord.OutcomeReason == RuleOutcomeReason.PreconditionFail)
                                ruleCounter--;
                        }

                        // Report outcome to dependency graph
                        if (ruleRecord.Outcome == RuleOutcome.Pass)
                            ruleBlockTarget.Pass();
                        else if (ruleRecord.Outcome == RuleOutcome.Fail || ruleRecord.Outcome == RuleOutcome.Error)
                            ruleBlockTarget.Fail();

                        AddToSummary(ruleBlock: ruleBlockTarget.Value, outcome: ruleRecord.Outcome);
                        if (ShouldOutput(ruleRecord.Outcome))
                            result.Add(ruleRecord);
                    }
                    finally
                    {
                        // Exit rule block scope
                        Context.ExitRuleBlock();
                    }
                }

                if (ruleCounter == 0)
                    Context.WarnObjectNotProcessed();

                if (_ResultFormat == ResultFormat.Summary)
                {
                    if (suppressedRuleCounter > 0)
                        Context.WarnRuleCountSuppressed(ruleCount: suppressedRuleCounter);

                    foreach (var keyValuePair in suppressionGroupCounter)
                        Context.WarnRuleSuppressionGroupCount(ruleCount: keyValuePair.Value, suppressionGroupId: keyValuePair.Key);
                }

                return result;
            }
            finally
            {
                Context.ExitTargetObject();
            }
        }