Exemplo n.º 1
0
        public static bool IsTargetSkipped(string message)
        {
            if (TargetAlreadyCompleteSuccess.IsMatch(message))
            {
                return(true);
            }

            if (TargetSkippedFalseCondition.IsMatch(message))
            {
                return(true);
            }

            if (TargetAlreadyCompleteFailure.IsMatch(message))
            {
                return(true);
            }

            if (TargetSkippedWhenSkipNonexistentTargets.IsMatch(message))
            {
                return(true);
            }
            //TargetAlreadyCompleteSuccess $:$ Target "{0}" skipped.Previously built successfully.
            //TargetSkippedFalseCondition $:$ Target "{0}" skipped, due to false condition; ({1}) was evaluated as ({2}).
            //TargetAlreadyCompleteFailure $:$ Target "{0}" skipped.Previously built unsuccessfully.
            //TargetSkippedWhenSkipNonexistentTargets"><value>Target "{0}" skipped. The target does not exist in the project and SkipNonexistentTargets is set to true.</value></data>

            return(false);
        }
        private static void InitializeRegex()
        {
            OutputPropertyMessagePrefix    = GetString("OutputPropertyLogMessage").Replace("{0}={1}", "");
            BuildingWithToolsVersionPrefix = new Regex(GetString("ToolsVersionInEffectForBuild").Replace("{0}", ".*?"));
            PropertyGroupMessagePrefix     = GetString("PropertyGroupLogMessage").Replace("{0}={1}", "");
            ForSearchPathPrefix            = new Regex(GetString("ResolveAssemblyReference.SearchPath").Replace("{0}", ".*?"));
            UnifiedPrimaryReferencePrefix  = new Regex(GetString("ResolveAssemblyReference.UnifiedPrimaryReference").Replace("{0}", ".*?"));
            PrimaryReferencePrefix         = new Regex(GetString("ResolveAssemblyReference.PrimaryReference").Replace("{0}", ".*?"));
            DependencyPrefix                        = new Regex(GetString("ResolveAssemblyReference.Dependency").Replace("{0}", ".*?"));
            UnifiedDependencyPrefix                 = new Regex(GetString("ResolveAssemblyReference.UnifiedDependency").Replace("{0}", ".*?"));
            AssemblyFoldersExLocation               = new Regex(GetString("ResolveAssemblyReference.AssemblyFoldersExSearchLocations").Replace("{0}", ".*?"));
            AdditionalPropertiesPrefix              = new Regex(GetString("General.AdditionalProperties").Replace("{0}", ".*?"));
            OverridingGlobalPropertiesPrefix        = new Regex(GetString("General.OverridingProperties").Replace("{0}", ".*?"));
            TargetAlreadyCompleteSuccess            = GetString("TargetAlreadyCompleteSuccess");
            TargetAlreadyCompleteSuccessRegex       = new Regex(TargetAlreadyCompleteSuccess.Replace("{0}", @".*?"));
            TargetAlreadyCompleteFailure            = GetString("TargetAlreadyCompleteFailure");
            TargetAlreadyCompleteFailureRegex       = new Regex(TargetAlreadyCompleteFailure.Replace("{0}", @".*?"));
            TargetSkippedWhenSkipNonexistentTargets = new Regex(GetString("TargetSkippedWhenSkipNonexistentTargets").Replace("{0}", @".*?"));
            RemovingProjectProperties               = new Regex(GetString("General.ProjectUndefineProperties").Replace("{0}", @".*?"));

            DuplicateImport = new Regex(GetString("SearchPathsForMSBuildExtensionsPath")
                                        .Replace("{0}", @".*?")
                                        .Replace("{1}", @".*?")
                                        .Replace("{2}", @".*?"));

            SearchPathsForMSBuildExtensionsPath = new Regex(GetString("SearchPathsForMSBuildExtensionsPath")
                                                            .Replace("{0}", @".*?")
                                                            .Replace("{1}", @".*?"));

            OverridingTarget = new Regex(GetString("OverridingTarget")
                                         .Replace("{0}", @".*?")
                                         .Replace("{1}", @".*?")
                                         .Replace("{2}", @".*?")
                                         .Replace("{3}", @".*?"));

            TryingExtensionsPath = new Regex(GetString("TryingExtensionsPath")
                                             .Replace("{0}", @".*?")
                                             .Replace("{1}", @".*?"));

            ProjectImported = GetString("ProjectImported");


            string projectImported = "^" + ProjectImported
                                     .Replace(".", "\\.")
                                     .Replace("{0}", @"(?<ImportedProject>[^\""]+)")
                                     .Replace("{1}", @"(?<File>[^\""]+)")
                                     .Replace("({2},{3})", @"\((?<Line>\d+),(?<Column>\d+)\)") + "$";

            ProjectImportedRegex = new Regex(projectImported, RegexOptions.Compiled);

            TargetSkippedFalseCondition = GetString("TargetSkippedFalseCondition");

            TargetSkippedFalseConditionRegex = new Regex(TargetSkippedFalseCondition
                                                         .Replace("{0}", @".*?")
                                                         .Replace("{1}", @".*?")
                                                         .Replace("{2}", @".*?")
                                                         );

            TaskSkippedFalseCondition = new Regex(GetString("TaskSkippedFalseCondition")
                                                  .Replace("{0}", @".*?")
                                                  .Replace("{1}", @".*?")
                                                  .Replace("{2}", @".*?")
                                                  );

            TargetDoesNotExistBeforeTargetMessage = new Regex(GetString("TargetDoesNotExistBeforeTargetMessage")
                                                              .Replace("{0}", @".*?")
                                                              .Replace("{1}", @".*?")
                                                              );

            CopyingFileFrom = new Regex(GetString("Copy.FileComment")
                                        .Replace("{0}", @"(?<From>[^\""]+)")
                                        .Replace("{1}", @"(?<To>[^\""]+)")
                                        );

            CreatingHardLink = new Regex(GetString("Copy.HardLinkComment")
                                         .Replace("{0}", @"(?<From>[^\""]+)")
                                         .Replace("{1}", @"(?<To>[^\""]+)")
                                         );

            DidNotCopy = new Regex(GetString("Copy.DidNotCopyBecauseOfFileMatch")
                                   .Replace("{0}", @"(?<From>[^\""]+)")
                                   .Replace("{1}", @"(?<To>[^\""]+)")
                                   .Replace("{2}", ".*?")
                                   .Replace("{3}", ".*?")
                                   );

            ProjectImportSkippedMissingFile = GetString("ProjectImportSkippedMissingFile");

            string skippedMissingFile = "^" + ProjectImportSkippedMissingFile
                                        .Replace(".", "\\.")
                                        .Replace("{0}", @"(?<ImportedProject>[^\""]+)")
                                        .Replace("{1}", @"(?<File>[^\""]+)")
                                        .Replace("({2},{3})", @"\((?<Line>\d+),(?<Column>\d+)\)");

            ProjectImportSkippedMissingFileRegex = new Regex(skippedMissingFile, RegexOptions.Compiled);

            ProjectImportSkippedInvalidFile = GetString("ProjectImportSkippedInvalidFile");

            string skippedInvalidFile = "^" + ProjectImportSkippedInvalidFile
                                        .Replace(".", "\\.")
                                        .Replace("{0}", @"(?<ImportedProject>[^\""]+)")
                                        .Replace("{1}", @"(?<File>[^\""]+)")
                                        .Replace("({2},{3})", @"\((?<Line>\d+),(?<Column>\d+)\)");

            ProjectImportSkippedInvalidFileRegex = new Regex(skippedInvalidFile, RegexOptions.Compiled);

            ProjectImportSkippedEmptyFile = GetString("ProjectImportSkippedEmptyFile");

            string skippedEmptyFile = "^" + ProjectImportSkippedEmptyFile
                                      .Replace(".", "\\.")
                                      .Replace("{0}", @"(?<ImportedProject>[^\""]+)")
                                      .Replace("{1}", @"(?<File>[^\""]+)")
                                      .Replace("({2},{3})", @"\((?<Line>\d+),(?<Column>\d+)\)");

            ProjectImportSkippedEmptyFileRegex = new Regex(skippedEmptyFile, RegexOptions.Compiled);

            ProjectImportSkippedNoMatches = GetString("ProjectImportSkippedNoMatches");

            string skippedNoMatches = "^" + ProjectImportSkippedNoMatches
                                      .Replace(".", "\\.")
                                      .Replace("{0}", @"(?<ImportedProject>[^\""]+)")
                                      .Replace("{1}", @"(?<File>.*)")
                                      .Replace("({2},{3})", @"\((?<Line>\d+),(?<Column>\d+)\)");

            ProjectImportSkippedNoMatchesRegex = new Regex(skippedNoMatches, RegexOptions.Compiled);

            PropertyReassignment = GetString("PropertyReassignment");

            // This was unused??
            //string propertyReassignment = PropertyReassignment
            // .Replace(@"$({0})=""{1}"" (", @"\$\(\w+\)=.*? \(")
            // .Replace(@"""{2}"")", @".*?""\)")
            // .Replace("{3}", @"(?<File>.*) \((?<Line>\d+),(\d+)\)$");
            //PropertyReassignmentRegex = new Regex("^" + propertyReassignment, RegexOptions.Compiled | RegexOptions.Singleline);

            PropertyReassignmentRegex = new Regex(PropertyReassignment
                                                  .Replace("{0}", ".*?")
                                                  .Replace("{1}", ".*?")
                                                  .Replace("{2}", ".*?")
                                                  .Replace("{3}", ".*?")
                                                  .Replace("$", @"\$")
                                                  .Replace("(", @"\(")
                                                  .Replace(")", @"\)"), RegexOptions.Compiled | RegexOptions.Singleline);

            string taskFoundFromFactory = GetString("TaskFoundFromFactory")
                                          .Replace(@"""{0}""", @"\""(?<task>.+)\""")
                                          .Replace(@"""{1}""", @"\""(?<assembly>.+)\""");

            TaskFoundFromFactory = new Regex("^" + taskFoundFromFactory, RegexOptions.Compiled);

            string taskFound = GetString("TaskFound")
                               .Replace(@"""{0}""", @"\""(?<task>.+)\""")
                               .Replace(@"""{1}""", @"\""(?<assembly>.+)\""");

            TaskFound = new Regex("^" + taskFound, RegexOptions.Compiled);

            ProjectImportSkippedFalseCondition = GetString("ProjectImportSkippedFalseCondition");

            string skippedFalseCondition = "^" + ProjectImportSkippedFalseCondition
                                           .Replace(".", "\\.")
                                           .Replace("{0}", @"(?<ImportedProject>[^\""]+)")
                                           .Replace("{1}", @"(?<File>[^\""]+)")
                                           .Replace("({2},{3})", @"\((?<Line>\d+),(?<Column>\d+)\)")
                                           .Replace("{4}", "(?<Reason>.+)")
                                           .Replace("{5}", "(?<Evaluated>.+)");

            ProjectImportSkippedFalseConditionRegex = new Regex(skippedFalseCondition, RegexOptions.Compiled);

            CouldNotResolveSdk      = GetString("CouldNotResolveSdk");
            CouldNotResolveSdkRegex = new Regex("^" + CouldNotResolveSdk
                                                .Replace("{0}", @"(?<Sdk>[^\""]+)"), RegexOptions.Compiled);

            ProjectImportSkippedExpressionEvaluatedToEmpty = GetString("ProjectImportSkippedExpressionEvaluatedToEmpty");

            string emptyCondition = "^" + ProjectImportSkippedExpressionEvaluatedToEmpty
                                    .Replace(".", "\\.")
                                    .Replace("{0}", @"(?<ImportedProject>[^\""]+)")
                                    .Replace("{1}", @"(?<File>[^\""]+)")
                                    .Replace("({2},{3})", @"\((?<Line>\d+),(?<Column>\d+)\)");

            ProjectImportSkippedExpressionEvaluatedToEmptyRegex = new Regex(emptyCondition, RegexOptions.Compiled);

            ConflictReferenceSameSDK = new Regex(GetString("GetSDKReferenceFiles.ConflictReferenceSameSDK")
                                                 .Replace("{0}", ".*?")
                                                 .Replace("{1}", ".*?")
                                                 .Replace("{2}", ".*?")
                                                 );

            ConflictRedistDifferentSDK = new Regex(GetString("GetSDKReferenceFiles.ConflictRedistDifferentSDK")
                                                   .Replace("{0}", ".*?")
                                                   .Replace("{1}", ".*?")
                                                   .Replace("{2}", ".*?")
                                                   .Replace("{3}", ".*?")
                                                   .Replace("{4}", ".*?")
                                                   );

            ConflictReferenceDifferentSDK = new Regex(GetString("GetSDKReferenceFiles.ConflictRedistDifferentSDK")
                                                      .Replace("{0}", ".*?")
                                                      .Replace("{1}", ".*?")
                                                      .Replace("{2}", ".*?")
                                                      .Replace("{3}", ".*?")
                                                      );

            TaskParameterMessagePrefix    = GetString("TaskParameterPrefix");
            OutputItemsMessagePrefix      = GetString("OutputItemParameterMessagePrefix");
            ItemGroupIncludeMessagePrefix = GetString("ItemGroupIncludeLogMessagePrefix");
            ItemGroupRemoveMessagePrefix  = GetString("ItemGroupRemoveLogMessage");
            GlobalPropertiesPrefix        = GetString("General.GlobalProperties");
            RemovingPropertiesPrefix      = GetString("General.UndefineProperties");
            EvaluationStarted             = GetString("EvaluationStarted");
            EvaluationFinished            = GetString("EvaluationFinished");
        }