internal virtual bool IsUpToDate()

in Common/Product/SharedProject/ProjectConfig.cs [609:734]
111 lines of code
22 McCabe index (conditional complexity)

        internal virtual bool IsUpToDate() {
            var outputWindow = OutputWindowRedirector.GetGeneral(ProjectMgr.Site);
#if DEBUG
            outputWindow.WriteLine(string.Format("Checking whether {0} needs to be rebuilt:", ProjectMgr.Caption));
#endif

            var latestInput = DateTime.MinValue;
            var earliestOutput = DateTime.MaxValue;
            bool mustRebuild = false;

            var allInputs = new HashSet<string>(OutputGroups
                .Where(g => IsInputGroup(g.Name))
                .SelectMany(x => x.EnumerateOutputs())
                .Select(input => input.CanonicalName),
                StringComparer.OrdinalIgnoreCase
            );
            foreach (var group in OutputGroups.Where(g => !IsInputGroup(g.Name))) {
                foreach (var output in group.EnumerateOutputs()) {
                    var path = output.CanonicalName;
#if DEBUG
                    var dt = TryGetLastWriteTimeUtc(path);
                    outputWindow.WriteLine(string.Format(
                        "  Out: {0}: {1} [{2}]",
                        group.Name,
                        path,
                        dt.HasValue ? dt.Value.ToString("s") : "err"
                    ));
#endif
                    DateTime? modifiedTime;

                    if (!File.Exists(path) ||
                        !(modifiedTime = TryGetLastWriteTimeUtc(path, outputWindow)).HasValue) {
                        mustRebuild = true;
                        break;
                    }

                    string inputPath;
                    if (File.Exists(inputPath = output.GetMetadata("SourceFile"))) {
                        var inputModifiedTime = TryGetLastWriteTimeUtc(inputPath, outputWindow);
                        if (inputModifiedTime.HasValue && inputModifiedTime.Value > modifiedTime.Value) {
                            mustRebuild = true;
                            break;
                        } else {
                            continue;
                        }
                    }

                    // output is an input, ignore it...
                    if (allInputs.Contains(path)) {
                        continue;
                    }

                    if (modifiedTime.Value < earliestOutput) {
                        earliestOutput = modifiedTime.Value;
                    }
                }

                if (mustRebuild) {
                    // Early exit if we know we're going to have to rebuild
                    break;
                }
            }

            if (mustRebuild) {
#if DEBUG
                outputWindow.WriteLine(string.Format(
                    "Rebuilding {0} because mustRebuild is true",
                    ProjectMgr.Caption
                ));
#endif
                return false;
            }

            foreach (var group in OutputGroups.Where(g => IsInputGroup(g.Name))) {
                foreach (var input in group.EnumerateOutputs()) {
                    var path = input.CanonicalName;
#if DEBUG
                    var dt = TryGetLastWriteTimeUtc(path);
                    outputWindow.WriteLine(string.Format(
                        "  In:  {0}: {1} [{2}]",
                        group.Name,
                        path,
                        dt.HasValue ? dt.Value.ToString("s") : "err"
                    ));
#endif
                    if (!File.Exists(path)) {
                        continue;
                    }

                    var modifiedTime = TryGetLastWriteTimeUtc(path, outputWindow);
                    if (modifiedTime.HasValue && modifiedTime.Value > latestInput) {
                        latestInput = modifiedTime.Value;
                        if (earliestOutput < latestInput) {
                            break;
                        }
                    }
                }

                if (earliestOutput < latestInput) {
                    // Early exit if we know we're going to have to rebuild
                    break;
                }
            }

            if (earliestOutput < latestInput) {
#if DEBUG
                outputWindow.WriteLine(string.Format(
                    "Rebuilding {0} because {1:s} < {2:s}",
                    ProjectMgr.Caption,
                    earliestOutput,
                    latestInput
                ));
#endif
                return false;
            } else {
#if DEBUG
                outputWindow.WriteLine(string.Format(
                    "Not rebuilding {0} because {1:s} >= {2:s}",
                    ProjectMgr.Caption,
                    earliestOutput,
                    latestInput
                ));
#endif
                return true;
            }
        }