Пример #1
0
        /// <summary>
        /// Analyzes the document.
        /// </summary>
        /// <param name="document">The document.</param>
        public override void AnalyzeDocument(CodeDocument document)
        {
            if (document == null) throw new ArgumentNullException("document");

            try
            {
                this.Bootstrapper();

                this.analyzerRegistry.RuleAnalyzers.ForEach(analyzer => analyzer.Initialize(this));
                this.analyzerRegistry.RuleAnalyzers.ForEach(analyzer => analyzer.VisitBeforeAnalysis(document));

                var csharpDocument = (CsDocument)document;

                this.VisiteDocument(csharpDocument);

                csharpDocument.WalkDocument(
                    this.VisitElement,
                    this.VisitStatement,
                    this.VisitExpression,
                    this.VisitQueryClause);

                csharpDocument.Tokens.ForEach(token =>
                    this.analyzerRegistry.RuleAnalyzers.ForEach(analyzer =>
                        analyzer.VisitToken(document, token)));

                this.analyzerRegistry.RuleAnalyzers.ForEach(analyzer => analyzer.VisitAfterAnalysis(document));
            }
            catch (Exception ex)
            {
                throw new Exception(ex.ToString());
            }
        }
Пример #2
0
        /// <summary>
        /// Runs the analyzers against the given document.
        /// </summary>
        /// <param name="document">
        /// The document to analyze.
        /// </param>
        /// <param name="parser">
        /// The parser that created the document.
        /// </param>
        /// <param name="analyzers">
        /// The analyzers to run against the document.
        /// </param>
        /// <param name="passNumber">
        /// The current pass number.
        /// </param>
        /// <returns>
        /// Returns true if analysis was run, or false if analysis was delayed until the next pass.
        /// </returns>
        private bool TestAndRunAnalyzers(CodeDocument document, SourceParser parser, IEnumerable <SourceAnalyzer> analyzers, int passNumber)
        {
            Param.AssertNotNull(document, "document");
            Param.AssertNotNull(parser, "parser");
            Param.Ignore(analyzers);
            Param.Ignore(passNumber);
            StyleCopTrace.In(document, parser, analyzers, passNumber);

            if (analyzers == null)
            {
                return(StyleCopTrace.Out(true));
            }

            // Determine whether any of the analyzers wish to delay analysis until the next pass.
            bool delay = false;

            foreach (SourceAnalyzer analyzer in analyzers)
            {
                if (analyzer.DelayAnalysis(document, passNumber))
                {
                    delay = true;
                    break;
                }
            }

            if (!delay)
            {
                this.RunAnalyzers(document, parser, analyzers);
            }

            return(StyleCopTrace.Out(!delay));
        }
Пример #3
0
        public override void AnalyzeDocument(CodeDocument document)
        {
            //if (!string.IsNullOrEmpty(_projectDir))
            //{
            //    return;
            //}

            System.Diagnostics.Debugger.Break();

            _projectDir = document.SourceCode.Project.Location;

            var folderList = this.GetSetting(document.Settings, "FolderList") as CollectionProperty;
            var folders = new List<string>();

            foreach (var i in folderList)
            {
                var path = Path.Combine(_projectDir, i);

                if (!Directory.Exists(path))
                {
                    folders.Add(i);
                }
            }

            if (folders.Count > 0)
            {
                var s = string.Join(", ", folders.ToArray());

                AddViolation(document.DocumentContents, "FoldersMustExist", s);
            }
        }
Пример #4
0
        internal void Validate(CodeDocument document)
        {
            this.ValidateAtLeastOneUsingDirectiveMustBePresent(document);
            this.ValidateFirstUsingDirectiveMustBeSystem();

            IEnumerable<UsingDirectiveGroup> groups =
                this.usingSettings.GetUsingDirectiveByGroup(this.usingDirectives).ToList();

            this.ValidateUsingGroupOrderMustBeRespected(groups);
            this.ValidateUsingGroupMustBeSeparatedByABlankLine(groups);

            foreach (UsingDirectiveGroup group in groups)
            {
                if (!this.usingSettings.AliasShouldBeLast)
                {
                    this.ValidateUsingDirectiveMustBeSortedAlphabeticallyInsideAGroup(group);
                }
                else
                {
                    this.ValidateAliasUsingDirectiveMustBeLastInsideAGroup(group);

                    this.ValidateUsingDirectiveMustBeSortedAlphabeticallyInsideAGroup(UsingValidator.GetGroupWithoutAlias(group));

                    this.ValidateAliasMustBeSortedAlphabeticallyInsideAGroup(UsingValidator.GetGroupWithOnlyAlias(group));
                }
            }
        }
Пример #5
0
		/// <summary>
		/// Analyzes source document.
		/// </summary>
		public void AnalyzeDocument(CodeDocument document)
		{
			CurrentNamingSettings settings = new CurrentNamingSettings();
			settings.Initialize(m_parent, document);

			CsDocument doc = (CsDocument)document;
			AnalyzeElements(doc.RootElement.ChildElements, settings);
		}
 public override void AnalyzeDocument(CodeDocument document)
 {
     CsDocument csdocument = (CsDocument)document;
     if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
     {
         csdocument.WalkDocument(null, null, new CodeWalkerExpressionVisitor<object>(this.VistExpression), null);
     }
 }
 public override void AnalyzeDocument(CodeDocument document)
 {
     CsDocument csdocument = (CsDocument)document;
     if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
     {
         csdocument.WalkDocument(elementCallback);
     }
 }
		/// <summary>
		/// Initializes settings from specified document.
		/// </summary>
		public void Initialize(SourceAnalyzer analyzer, CodeDocument document)
		{
			InitializeCommon(analyzer, document);
			InitializeDerivings(analyzer, document);
			InitializeBlockAt(analyzer, document);
			InitializeEnglishOnly(analyzer, document);
			InitializeCheckLength(analyzer, document);
		}
 public override void AnalyzeDocument(CodeDocument document)
 {
     CsDocument csdocument = (CsDocument)document;
     if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
     {
         this.CheckSpacing(csdocument.Tokens, false, null);
     }
 }
Пример #10
0
 public override void AnalyzeDocument(CodeDocument document)
 {
     CsDocument csdocument = (CsDocument)document;
     if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
     {
         csdocument.WalkDocument(delegate { return true; }, delegate { return true; }, this.ExpressionCallback);
     }
 }
Пример #11
0
        /// <summary>
        /// Runs the list of analyzers against the given document.
        /// </summary>
        /// <param name="document">
        /// The document to analyze.
        /// </param>
        /// <param name="parser">
        /// The parser that created the document.
        /// </param>
        /// <param name="analyzers">
        /// The list of analyzers to run against the document.
        /// </param>
        private void RunAnalyzers(CodeDocument document, SourceParser parser, IEnumerable <SourceAnalyzer> analyzers)
        {
            Param.AssertNotNull(document, "document");
            Param.AssertNotNull(parser, "parser");
            Param.Ignore(analyzers, "analyzers");
            StyleCopTrace.In(document, parser, analyzers);

            if (analyzers != null)
            {
                if (parser.SkipAnalysisForDocument(document.SourceCode))
                {
                    string format = string.Format(CultureInfo.CurrentCulture, "Skipping: {0} - {1}", document.SourceCode.Project.Location.SubstringAfterLast('\\'), GetRelativeFileName(document.SourceCode));
                    this.data.Core.SignalOutput(MessageImportance.Normal, format);
                }
                else
                {
                    // Loop through each of the parser's analyzers.
                    // Only call analyzers that are also in the enabled list.
                    foreach (SourceAnalyzer analyzer in parser.Analyzers)
                    {
                        SourceAnalyzer localAnalyzer = analyzer;
                        if (analyzers.Any(enabledAnalyzers => enabledAnalyzers.Id == localAnalyzer.Id))
                        {
                            // Make sure the user hasn't cancelled us.
                            if (this.data.Core.Cancel)
                            {
                                break;
                            }

                            SourceParser.ClearAnalyzerTags(document);
                            try
                            {
                                if (analyzer.DoAnalysis(document))
                                {
                                    analyzer.AnalyzeDocument(document);
                                }
                            }
                            catch (Exception ex)
                            {
                                StringBuilder details = new StringBuilder();
                                details.AppendLine(string.Format(CultureInfo.CurrentCulture, "Exception thrown by analyzer '{0}' while processing '{1}'.", analyzer.Name, document.SourceCode.Path));

                                // Add exception message for help on bugfix.
                                if (!string.IsNullOrEmpty(ex.Message))
                                {
                                    details.AppendLine(string.Format(CultureInfo.CurrentCulture, "Exception message : {0}", ex.Message));
                                }

                                this.data.Core.SignalOutput(MessageImportance.High, details.ToString());
                                throw;
                            }
                        }
                    }
                }
            }

            StyleCopTrace.Out();
        }
Пример #12
0
        /// <summary>
        /// Clears the analyzer tags for the given document and all of its children.
        /// </summary>
        /// <param name="document">
        /// The document to clear.
        /// </param>
        /// <remarks>
        /// <para>
        /// During each analysis run, analyzers can store data within each analyzed document for
        /// later use. Analyzers store and retrieve this data using the <see cref="SourceAnalyzer.GetDocumentData"/>
        /// and <see cref="SourceAnalyzer.SetDocumentData"/> methods.
        /// </para>
        /// <para>
        /// After all analysis has been completed, this analyzer data should be cleared so that
        /// it will not conflict with the next analysis. This method can be called to clear all
        /// analyzer data which was stored during the previous analysis.
        /// </para>
        /// </remarks>
        internal static void ClearAnalyzerTags(CodeDocument document)
        {
            Param.AssertNotNull(document, "document");

            if (document != null && document.DocumentContents != null)
            {
                document.DocumentContents.ClearAnalyzerTags();
            }
        }
Пример #13
0
        /// <summary>
        /// Analyzes source document.
        /// </summary>
        public void AnalyzeDocument(CodeDocument document)
        {
            CustomRulesSettings settings = new CustomRulesSettings();
            settings.Initialize(m_parent, document);

            CsDocument doc = (CsDocument)document;
            AnalyzePlainText(doc, settings);
            AnalyzeElements(doc.RootElement.ChildElements, settings);
        }
Пример #14
0
        public override void AnalyzeDocument(CodeDocument currentCodeDocument)
        {
            var codeDocument = (CsDocument)currentCodeDocument;

            if (codeDocument.RootElement != null && !codeDocument.RootElement.Generated)
            {
                _filename = codeDocument.SourceCode.Name;
                codeDocument.WalkDocument(new CodeWalkerElementVisitor <object>(this.InspectCurrentElement), null, null);
            }
        }
Пример #15
0
        /// <summary>
        /// Gets the data saved by this analyzer within the given document.
        /// </summary>
        /// <param name="document">
        /// The document containing the data.
        /// </param>
        /// <returns>
        /// Returns the data if it exists.
        /// </returns>
        protected object GetDocumentData(CodeDocument document)
        {
            Param.RequireNotNull(document, "document");

            object data = null;

            document.AnalyzerData.TryGetValue(this.Id, out data);

            return(data);
        }
Пример #16
0
		public override void AnalyzeDocument(CodeDocument document)
		{
			Param.RequireNotNull(document, "document");

			var csdocument = (CsDocument)document;
			if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
			{
				CheckSpacing(csdocument.Tokens);
			}
		}
        public override void AnalyzeDocument(CodeDocument document)
        {
            CsDocument csdocument = (CsDocument)document;
            if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
            {
                csdocument.WalkDocument(new CodeWalkerElementVisitor<object>(this.AnalyzeSourceCodeForNamingConvention), null, null);
                csdocument.WalkDocument(new CodeWalkerElementVisitor<object>(this.AnalyzeSourceCodeForComments), null, null);

            }
        }
		/// <summary>
		/// Analyzes source document.
		/// </summary>
		public void AnalyzeDocument(CodeDocument document)
		{
			CheckOriginalRule(document, Constants.LayoutRulesAnalyzerId, Rules.ElementMustNotBeOnSingleLine);
			CheckOriginalRule(document, Constants.LayoutRulesAnalyzerId, Rules.ClosingCurlyBracketMustBeFollowedByBlankLine);
			CheckOriginalRule(document, Constants.LayoutRulesAnalyzerId, Rules.ElementsMustBeSeparatedByBlankLine);

			m_customNamingAnalyzer.AnalyzeDocument(document);
			m_customLayoutAnalyzer.AnalyzeDocument(document);
			m_customDocumentationAnalyzer.AnalyzeDocument(document);
		}
Пример #19
0
        public override void AnalyzeDocument(CodeDocument currentCodeDocument)
        {
            var codeDocument = (CsDocument)currentCodeDocument;

            if (codeDocument.RootElement != null && !codeDocument.RootElement.Generated)
            {

                codeDocument.WalkDocument(new CodeWalkerElementVisitor<object>(this.InspectCurrentElement), null, null);

            }
        }
Пример #20
0
 public override void AnalyzeDocument(CodeDocument document)
 {
     var csharpDocument = (CsDocument)document;
     if (csharpDocument.RootElement != null && !csharpDocument.RootElement.Generated)
     {
         CheckLineSpace(
             csharpDocument,
             IsRuleEnabled(csharpDocument, TrailingWhiteSpacesRuleName),
             IsRuleEnabled(csharpDocument, TabIndentationRuleName));
     }
 }
        /// <summary>
        /// Extremely simple analyzer for demo purposes.
        /// </summary>
        public override void AnalyzeDocument(CodeDocument document)
        {
            CsDocument doc = (CsDocument)document;

            // skipping wrong or auto-generated documents
            if (doc.RootElement == null || doc.RootElement.Generated)
                return;

            // check all class entries
            doc.WalkDocument(CheckClasses);
        }
Пример #22
0
 public override void AnalyzeDocument(CodeDocument document)
 {
     var csharpDocument = (CsDocument)document;
     if (csharpDocument.RootElement != null && !csharpDocument.RootElement.Generated)
     {
         if (IsRuleEnabled(csharpDocument, RuleName))
         {
             CheckDocumentHeader(csharpDocument);
         }
     }
 }
Пример #23
0
        /// <summary>
        /// Gets a value indicating whether the given rule is enabled for the given document.
        /// </summary>
        /// <param name="document">
        /// The document.
        /// </param>
        /// <param name="ruleName">
        /// The rule to check.
        /// </param>
        /// <returns>
        /// Returns true if the rule is enabled; otherwise false.
        /// </returns>
        public override bool IsRuleEnabled(CodeDocument document, string ruleName)
        {
            Param.RequireNotNull(document, "document");
            Param.RequireValidString(ruleName, "ruleName");

            if (document.SourceCode == null || document.SourceCode.Settings == null)
            {
                return(true);
            }

            return(document.SourceCode.Settings.IsRuleEnabled(this, ruleName));
        }
Пример #24
0
		/// <summary>
		/// Checks whether specified rule is enabled.
		/// </summary>
		public override bool IsRuleEnabled(CodeDocument document, string ruleName)
		{
			if (SpecialRunningParameters != null)
			{
				if (!String.IsNullOrEmpty(SpecialRunningParameters.OnlyEnabledRule))
				{
					return ruleName == SpecialRunningParameters.OnlyEnabledRule;
				}
			}

			return base.IsRuleEnabled(document, ruleName);
		}
Пример #25
0
		/// <summary>
		/// Analyzes source document.
		/// </summary>
		public override void AnalyzeDocument(CodeDocument document)
		{
			CsDocument doc = (CsDocument)document;
			if (doc.RootElement == null
				|| doc.RootElement.Generated)
				return;

			if (IsRuleEnabled(document, Rules.AdvancedNamingRules.ToString()))
				m_advancedNamingRules.AnalyzeDocument(document);

			m_extendedOriginalRules.AnalyzeDocument(document);
			m_moreCustomRules.AnalyzeDocument(document);
		}
Пример #26
0
        /// <summary>
        /// Extremely simple analyser for demo purposes
        /// </summary>
        /// <param name="document">
        /// The complete code document being passed in for inspection
        /// </param>
        public override void AnalyzeDocument(CodeDocument document)
        {
            Param.RequireNotNull(document, "document");
            var doc = (CsDocument)document;

            // skipping wrong or auto-generated documents
            if (doc.RootElement == null || doc.RootElement.Generated)
            {
                return;
            }

            // check all class entries
            doc.WalkDocument(this.CheckClasses);
        }
Пример #27
0
        /// <summary>
        /// Stores the given data object within the given document.
        /// </summary>
        /// <param name="document">
        /// The document to store the data within.
        /// </param>
        /// <param name="data">
        /// The data to store.
        /// </param>
        protected void SetDocumentData(CodeDocument document, object data)
        {
            Param.RequireNotNull(document, "document");
            Param.Ignore(data);

            if (document.AnalyzerData.ContainsKey(this.Id))
            {
                document.AnalyzerData[this.Id] = data;
            }
            else
            {
                document.AnalyzerData.Add(this.Id, data);
            }
        }
        /// <summary>
        /// This method will analyze the document and call the routine that
        /// will make the determination whether this rule has been violated.
        /// </summary>
        /// <param name="document">A document of things.</param>
        public override void AnalyzeDocument(CodeDocument document)
        {
            var csdocument = (CsDocument)document;

            if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
            {
                csdocument.WalkDocument(this.PublicConstructorsShouldBeDocumented, null, null);
                csdocument.WalkDocument(this.PublicMethodsShouldBeDocumented, null, null);
                csdocument.WalkDocument(this.PublicPropertiesShouldBeDocumented, null, null);
                csdocument.WalkDocument(this.InternalConstructorsShouldBeDocumented, null, null);
                csdocument.WalkDocument(this.InternalMethodsShouldBeDocumented, null, null);
                csdocument.WalkDocument(this.InternalPropertiesShouldBeDocumented, null, null);
                csdocument.WalkDocument(this.RegionMustBeSeparatedByBlankLine, null, null);
                csdocument.WalkDocument(this.RegionNameMustHaveFirstLetterCapitalized, null, null);
            }
        }
Пример #29
0
        public override bool DoAnalysis(CodeDocument document)
        {
            var doc = (CsDocument)document;

            // skipping wrong or auto-generated documents
            if (doc.RootElement == null || doc.RootElement.Generated)
            {
                return true;
            }

            if (IsRuleEnabled(document, RuleName))
            {
                doc.WalkDocument(null, null, VisitExpression);
            }

            return true;
        }
Пример #30
0
        /// <summary>
        /// Exports the violations found within this document into the given xml node.
        /// </summary>
        /// <param name="document">
        /// The document containing the violations.
        /// </param>
        /// <param name="violationsDocument">
        /// The xml document in which to store the violation information.
        /// </param>
        /// <param name="parentNode">
        /// The parent node within this xml document under which to store the violation information.
        /// </param>
        internal static void ExportViolations(CodeDocument document, XmlDocument violationsDocument, XmlNode parentNode)
        {
            Param.AssertNotNull(document, "document");
            Param.AssertNotNull(violationsDocument, "violationsDocument");
            Param.AssertNotNull(parentNode, "parentNode");

            if (document.DocumentContents != null)
            {
                SourceParser.ExportElementViolations(document.DocumentContents, violationsDocument, parentNode);
            }

            if (document.SourceCode != null)
            {
                // Add the violations from the source code.
                foreach (Violation violation in document.SourceCode.Violations)
                {
                    SourceParser.ExportViolation(violation, violationsDocument, parentNode);
                }
            }
        }
Пример #31
0
        //public override void VisitElement(CsElement element, CsElement parentElement, object context)
        //{
        //    if (element.ElementType == ElementType.Root)
        //    {
        //        element.
        //    }
        //}
        /// <summary>
        /// Visits the token.
        /// </summary>
        /// <param name="document">The document.</param>
        /// <param name="token">The token.</param>
        public override void VisitToken(CodeDocument document, CsToken token)
        {
            if (token.CsTokenType == CsTokenType.EndOfLine && this.lastTokenWasWhitespace)
            {
                this.SourceAnalyzer.AddViolation(document.DocumentContents, token.LineNumber, ContribRule.NoTrailingWhiteSpace);
            }

            if (this.isBeginningOfLine)
            {
                if ((token.CsTokenType == CsTokenType.WhiteSpace) &&
                    (!SpacingAnalyzer.IsValidIndentationWhitespace(token.Text)))
                {
                    this.SourceAnalyzer.AddViolation(document.DocumentContents, token.LineNumber, ContribRule.IndentUsingTabs);
                }

                this.isBeginningOfLine = false;
            }

            this.lastTokenWasWhitespace = token.CsTokenType == CsTokenType.WhiteSpace;
            if (token.CsTokenType == CsTokenType.EndOfLine) this.isBeginningOfLine = true;
        }
Пример #32
0
        /// <summary>
        /// Runs the analyzers against the given document.
        /// </summary>
        /// <param name="document">
        /// The document to analyze.
        /// </param>
        /// <param name="parser">
        /// The parser that created the document.
        /// </param>
        /// <param name="analyzers">
        /// The analyzers to run against the document.
        /// </param>
        /// <param name="passNumber">
        /// The current pass number.
        /// </param>
        /// <returns>
        /// Returns true if analysis was run, or false if analysis was delayed until the next pass.
        /// </returns>
        private bool TestAndRunAnalyzers(CodeDocument document, SourceParser parser, IEnumerable<SourceAnalyzer> analyzers, int passNumber)
        {
            Param.AssertNotNull(document, "document");
            Param.AssertNotNull(parser, "parser");
            Param.Ignore(analyzers);
            Param.Ignore(passNumber);
            StyleCopTrace.In(document, parser, analyzers, passNumber);

            if (analyzers == null)
            {
                return StyleCopTrace.Out(true);
            }

            // Determine whether any of the analyzers wish to delay analysis until the next pass.
            bool delay = false;
            foreach (SourceAnalyzer analyzer in analyzers)
            {
                if (analyzer.DelayAnalysis(document, passNumber))
                {
                    delay = true;
                    break;
                }
            }

            if (!delay)
            {
                this.RunAnalyzers(document, parser, analyzers);
            }

            return StyleCopTrace.Out(!delay);
        }
Пример #33
0
 /// <summary>
 /// Analyzes a code document.
 /// </summary>
 /// <param name="document">
 /// The document to analyze.
 /// </param>
 public virtual void AnalyzeDocument(CodeDocument document)
 {
     Param.Ignore(document);
 }
        /// <inheritdoc />
        public override bool DoAnalysis(CodeDocument document)
        {
            Param.RequireNotNull(document, "document");

            CsDocument csdocument = (CsDocument)document;

            return csdocument.FileHeader == null || !csdocument.FileHeader.UnStyled;
        }
        /// <summary>
        /// Checks the methods within the given document.
        /// </summary>
        /// <param name="document">The document to check.</param>
        public override void AnalyzeDocument(CodeDocument document)
        {
            Param.RequireNotNull(document, "document");

            CsDocument csdocument = (CsDocument)document;

            if (csdocument.RootElement != null && !csdocument.RootElement.Generated)
            {
                // Check the access modifier rules.
                TopLevelElements topLevelElements = new TopLevelElements();

                csdocument.WalkDocument<TopLevelElements>(
                    new CodeWalkerElementVisitor<TopLevelElements>(this.ProcessElement),
                    new CodeWalkerStatementVisitor<TopLevelElements>(this.ProcessStatement),
                    new CodeWalkerExpressionVisitor<TopLevelElements>(this.ProcessExpression),
                    topLevelElements);

                // If there is more than one top-level class in the file, make sure they are all
                // partial classes and are all of the same type.
                if (topLevelElements.Classes.Count > 1)
                {
                    string name = string.Empty;
                    foreach (Class classElement in topLevelElements.Classes)
                    {
                        if (!classElement.Declaration.ContainsModifier(CsTokenType.Partial) ||
                            (!string.IsNullOrEmpty(name) && string.Compare(name, classElement.FullNamespaceName, StringComparison.Ordinal) != 0))
                        {
                            // Set the violation line number to the second class in the file.
                            int count = 0;
                            foreach (Class c in topLevelElements.Classes)
                            {
                                if (count == 1)
                                {
                                    this.AddViolation(c, c.LineNumber, Rules.FileMayOnlyContainASingleClass);
                                    break;
                                }

                                ++count;
                            }

                            break;
                        }

                        name = classElement.FullNamespaceName;
                    }
                }

                // If there is more than one namespace in the file, this is a violation.
                if (topLevelElements.Namespaces.Count > 1)
                {
                    // Set the violation line number to the second namespace in the file.
                    int count = 0;
                    foreach (Namespace n in topLevelElements.Namespaces)
                    {
                        if (count == 1)
                        {
                            this.AddViolation(n, n.LineNumber, Rules.FileMayOnlyContainASingleNamespace);
                            break;
                        }

                        ++count;
                    }
                }
            }
        }
Пример #36
0
 public abstract bool ParseFile(SourceCode sourceCode, int passNumber, ref CodeDocument document);
Пример #37
0
 /// <summary>
 /// Parses a source code document.
 /// </summary>
 /// <param name="sourceCode">
 /// The source code to parse.
 /// </param>
 /// <param name="passNumber">
 /// The current pass number.
 /// </param>
 /// <param name="document">
 /// The parsed representation of the file.
 /// </param>
 /// <returns>
 /// Returns false if no further parsing should be done on this file.
 /// </returns>
 public override bool ParseFile(SourceCode sourceCode, int passNumber, ref CodeDocument document)
 {
     Param.Ignore(sourceCode, passNumber, document);
     throw new NotImplementedException();
 }
Пример #38
0
        /// <summary>
        /// Runs the list of analyzers against the given document.
        /// </summary>
        /// <param name="document">
        /// The document to analyze.
        /// </param>
        /// <param name="parser">
        /// The parser that created the document.
        /// </param>
        /// <param name="analyzers">
        /// The list of analyzers to run against the document.
        /// </param>
        private void RunAnalyzers(CodeDocument document, SourceParser parser, IEnumerable<SourceAnalyzer> analyzers)
        {
            Param.AssertNotNull(document, "document");
            Param.AssertNotNull(parser, "parser");
            Param.Ignore(analyzers, "analyzers");
            StyleCopTrace.In(document, parser, analyzers);

            if (analyzers != null)
            {
                if (parser.SkipAnalysisForDocument(document.SourceCode))
                {
                    string format = string.Format(CultureInfo.CurrentCulture, "Skipping: {0} - {1}", document.SourceCode.Project.Location.SubstringAfterLast('\\'), GetRelativeFileName(document.SourceCode));
                    this.data.Core.SignalOutput(MessageImportance.Normal, format);
                }
                else
                {
                    // Loop through each of the parser's analyzers. 
                    // Only call analyzers that are also in the enabled list.
                    foreach (SourceAnalyzer analyzer in parser.Analyzers)
                    {
                        SourceAnalyzer localAnalyzer = analyzer;
                        if (analyzers.Any(enabledAnalyzers => enabledAnalyzers.Id == localAnalyzer.Id))
                        {
                            // Make sure the user hasn't cancelled us.
                            if (this.data.Core.Cancel)
                            {
                                break;
                            }

                            SourceParser.ClearAnalyzerTags(document);
                            try
                            {
                                if (analyzer.DoAnalysis(document))
                                {
                                    analyzer.AnalyzeDocument(document);
                                }
                            }
                            catch (Exception ex)
                            {
                                StringBuilder details = new StringBuilder();
                                details.AppendLine(string.Format(CultureInfo.CurrentCulture, "Exception thrown by analyzer '{0}' while processing '{1}'.", analyzer.Name, document.SourceCode.Path));

                                // Add exception message for help on bugfix.
                                if (!string.IsNullOrEmpty(ex.Message))
                                {
                                    details.AppendLine(string.Format(CultureInfo.CurrentCulture, "Exception message : {0}"));
                                }

                                this.data.Core.SignalOutput(MessageImportance.High, details.ToString());
                                throw;
                            }
                        }
                    }
                }
            }

            StyleCopTrace.Out();
        }
Пример #39
0
		/// <summary>
		/// Checks whether specified rule is enabled.
		/// </summary>
		public override bool IsRuleEnabled(CodeDocument document, string ruleName)
		{
			return true;
		}
Пример #40
0
        /// <summary>
        /// Saves the given code document results into a cache document.
        /// </summary>
        /// <param name="document">
        /// The document to save.
        /// </param>
        /// <param name="parser">
        /// The parser that created the document.
        /// </param>
        /// <param name="settingsTimeStamp">
        /// The time when the settings were last updated.
        /// </param>
        /// <returns>
        /// Returns true if the document was saved.
        /// </returns>
        public bool SaveDocumentResults(CodeDocument document, SourceParser parser, DateTime settingsTimeStamp)
        {
            Param.AssertNotNull(document, "document");
            Param.AssertNotNull(parser, "parser");
            Param.Ignore(settingsTimeStamp);

            bool success = false;

            lock (this)
            {
                try
                {
                    XmlDocument xml;
                    if (!this.documentHash.ContainsKey(document.SourceCode.Project.Location))
                    {
                        XmlNode temp;
                        xml = this.OpenResultsCache(document.SourceCode, parser, out temp);
                        if (xml != null)
                        {
                            this.documentHash.Add(document.SourceCode.Project.Location, xml);
                        }
                    }
                    else
                    {
                        xml = this.documentHash[document.SourceCode.Project.Location];
                    }

                    if (xml != null)
                    {
                        XmlNode remove =
                            xml.DocumentElement.SelectSingleNode(
                                string.Format(CultureInfo.InvariantCulture, "sourcecode[@name=\"{0}\"][@parser=\"{1}\"]", document.SourceCode.Name, parser.Id));
                        if (remove != null)
                        {
                            xml.DocumentElement.RemoveChild(remove);
                        }
                    }
                    else
                    {
                        xml = new XmlDocument();

                        // Create the document node.
                        xml.AppendChild(xml.CreateElement("stylecopresultscache"));

                        // Add the version.
                        XmlNode versionNode = xml.CreateElement("version");
                        xml.DocumentElement.AppendChild(versionNode);
                        versionNode.InnerText = ResultsCache.Version;

                        if (this.documentHash.ContainsKey(document.SourceCode.Project.Location))
                        {
                            this.documentHash.Remove(document.SourceCode.Project.Location);
                        }

                        this.documentHash.Add(document.SourceCode.Project.Location, xml);
                    }

                    XmlNode root = xml.CreateElement("sourcecode");
                    XmlAttribute name = xml.CreateAttribute("name");
                    name.Value = document.SourceCode.Name;
                    root.Attributes.Append(name);
                    xml.DocumentElement.AppendChild(root);

                    // Create the timestamps node.
                    // We need to store the timestamp of all files that were used to create the violation.
                    // Parser, Rules, settings, source file, spell checker, and dictionaries.
                    XmlElement node = xml.CreateElement("timestamps");
                    root.AppendChild(node);

                    this.AddTimestampToXml(xml, node, "styleCop", this.core.TimeStamp);

                    this.AddTimestampToXml(xml, node, "settingsFile", settingsTimeStamp);

                    // Stores the last write time of the source code.
                    this.AddTimestampToXml(xml, node, "sourceFile", document.SourceCode.TimeStamp);

                    // Store all the rules and parser timestamps
                    this.AddTimestampToXml(xml, node, "parser", document.SourceCode.Parser.TimeStamp);

                    foreach (SourceAnalyzer analyzer in document.SourceCode.Parser.Analyzers)
                    {
                        this.AddTimestampToXml(xml, node, analyzer.Id, analyzer.TimeStamp);
                        this.AddHashCodeToXml(xml, node, analyzer.Id + ".FilesHashCode", analyzer.GetDependantFilesHashCode(document.SourceCode.Project.Culture));
                    }

                    // Add the parser ID attribute.
                    if (document.SourceCode.Parser != null)
                    {
                        XmlAttribute attribute = xml.CreateAttribute("parser");
                        root.Attributes.Append(attribute);
                        attribute.Value = document.SourceCode.Parser.Id;
                    }

                    // Create the violations node.
                    node = xml.CreateElement("violations");
                    root.AppendChild(node);

                    // Add the violations.
                    SourceParser.ExportViolations(document, xml, node);

                    success = true;
                }
                catch (XmlException)
                {
                }
            }

            return success;
        }
Пример #41
0
 /// <summary>
 /// Determines whether the analyzer wishes to delay its analysis until a later pass.
 /// </summary>
 /// <param name="document">
 /// The document to analyze.
 /// </param>
 /// <param name="passNumber">
 /// The current pass number.
 /// </param>
 /// <returns>
 /// Returns true if the analysis should be delayed until the next pass, or
 /// false if the analysis should be performed in the current pass.
 /// </returns>
 public virtual bool DelayAnalysis(CodeDocument document, int passNumber)
 {
     Param.Ignore(document, passNumber);
     return(false);
 }
Пример #42
0
 /// <summary>
 /// Gets a value indicating whether the given rule is enabled for the given document.
 /// </summary>
 /// <param name="document">
 /// The document.
 /// </param>
 /// <param name="ruleName">
 /// The rule to check.
 /// </param>
 /// <returns>
 /// Returns true if the rule is enabled; otherwise false.
 /// </returns>
 public virtual bool IsRuleEnabled(CodeDocument document, string ruleName)
 {
     Param.Ignore(document, ruleName);
     return(true);
 }
Пример #43
0
 /// <summary>
 /// Give the analyzer a final chance to stop the analysis of this document.
 /// </summary>
 /// <param name="document">
 /// The document to check to see if we need to actually continue.
 /// </param>
 /// <returns>
 /// True if the document should be analyzed otherwise False.
 /// </returns>
 public virtual bool DoAnalysis(CodeDocument document)
 {
     Param.Ignore(document);
     return(true);
 }
Пример #44
0
        private void ValidateAtLeastOneUsingDirectiveMustBePresent(CodeDocument document)
        {
            if (this.usingDirectives.Count() == 0)
            {
                DocumentRoot rootElement = ((CsDocument)document).RootElement;

                this.sourceAnalyzer.AddViolation(rootElement, rootElement.LineNumber,
                    ContribRule.FirstUsingDirectiveMustBeSystem);
            }
        }
Пример #45
0
        /// <summary>
        /// Saves the given code document results into a cache document.
        /// </summary>
        /// <param name="document">
        /// The document to save.
        /// </param>
        /// <param name="parser">
        /// The parser that created the document.
        /// </param>
        /// <param name="settingsTimeStamp">
        /// The time when the settings were last updated.
        /// </param>
        /// <returns>
        /// Returns true if the document was saved.
        /// </returns>
        public bool SaveDocumentResults(CodeDocument document, SourceParser parser, DateTime settingsTimeStamp)
        {
            Param.AssertNotNull(document, "document");
            Param.AssertNotNull(parser, "parser");
            Param.Ignore(settingsTimeStamp);

            bool success = false;

            lock (this)
            {
                try
                {
                    XmlDocument xml;
                    if (!this.documentHash.ContainsKey(document.SourceCode.Project.Location))
                    {
                        XmlNode temp;
                        xml = this.OpenResultsCache(document.SourceCode, parser, out temp);
                        if (xml != null)
                        {
                            this.documentHash.Add(document.SourceCode.Project.Location, xml);
                        }
                    }
                    else
                    {
                        xml = this.documentHash[document.SourceCode.Project.Location];
                    }

                    if (xml != null)
                    {
                        XmlNode remove =
                            xml.DocumentElement.SelectSingleNode(
                                string.Format(CultureInfo.InvariantCulture, "sourcecode[@name=\"{0}\"][@parser=\"{1}\"]", document.SourceCode.Name, parser.Id));
                        if (remove != null)
                        {
                            xml.DocumentElement.RemoveChild(remove);
                        }
                    }
                    else
                    {
                        xml = new XmlDocument();

                        // Create the document node.
                        xml.AppendChild(xml.CreateElement("stylecopresultscache"));

                        // Add the version.
                        XmlNode versionNode = xml.CreateElement("version");
                        xml.DocumentElement.AppendChild(versionNode);
                        versionNode.InnerText = ResultsCache.Version;

                        if (this.documentHash.ContainsKey(document.SourceCode.Project.Location))
                        {
                            this.documentHash.Remove(document.SourceCode.Project.Location);
                        }

                        this.documentHash.Add(document.SourceCode.Project.Location, xml);
                    }

                    XmlNode      root = xml.CreateElement("sourcecode");
                    XmlAttribute name = xml.CreateAttribute("name");
                    name.Value = document.SourceCode.Name;
                    root.Attributes.Append(name);
                    xml.DocumentElement.AppendChild(root);

                    // Create the timestamps node.
                    // We need to store the timestamp of all files that were used to create the violation.
                    // Parser, Rules, settings, source file, spell checker, and dictionaries.
                    XmlElement node = xml.CreateElement("timestamps");
                    root.AppendChild(node);

                    this.AddTimestampToXml(xml, node, "styleCop", this.core.TimeStamp);

                    this.AddTimestampToXml(xml, node, "settingsFile", settingsTimeStamp);

                    // Stores the last write time of the source code.
                    this.AddTimestampToXml(xml, node, "sourceFile", document.SourceCode.TimeStamp);

                    // Store all the rules and parser timestamps
                    this.AddTimestampToXml(xml, node, "parser", document.SourceCode.Parser.TimeStamp);

                    foreach (SourceAnalyzer analyzer in document.SourceCode.Parser.Analyzers)
                    {
                        this.AddTimestampToXml(xml, node, analyzer.Id, analyzer.TimeStamp);
                        this.AddHashCodeToXml(xml, node, analyzer.Id + ".FilesHashCode", analyzer.GetDependantFilesHashCode(document.SourceCode.Project.Culture));
                    }

                    // Add the parser ID attribute.
                    if (document.SourceCode.Parser != null)
                    {
                        XmlAttribute attribute = xml.CreateAttribute("parser");
                        root.Attributes.Append(attribute);
                        attribute.Value = document.SourceCode.Parser.Id;
                    }

                    // Create the violations node.
                    node = xml.CreateElement("violations");
                    root.AppendChild(node);

                    // Add the violations.
                    SourceParser.ExportViolations(document, xml, node);

                    success = true;
                }
                catch (XmlException)
                {
                }
            }

            return(success);
        }
Пример #46
0
        /// <summary>
        /// Parses and analyzes the given document.
        /// </summary>
        /// <param name="sourceCode">
        /// The document to parse and analyze.
        /// </param>
        /// <param name="documentStatus">
        /// The current status of the documents.
        /// </param>
        private void ParseAndAnalyzeDocument(SourceCode sourceCode, DocumentAnalysisStatus documentStatus)
        {
            Param.AssertNotNull(sourceCode, "sourceCode");
            Param.AssertNotNull(documentStatus, "documentStatus");
            StyleCopTrace.In(sourceCode, documentStatus);

            // Signal the output for this document.
            this.data.Core.SignalOutput(
                MessageImportance.Low, string.Format(CultureInfo.CurrentCulture, "Pass {0}:   {1}", this.data.PassNumber + 1, GetSignalOutputGetText(sourceCode)));

            // Extract the document to parse.
            CodeDocument parsedDocument = documentStatus.Document;

            // Get or load the analyzer list.
            IEnumerable <SourceAnalyzer> analyzers = sourceCode.Settings.EnabledAnalyzers;

            // Parse the document.
            bool parsingCompleted;

            try
            {
                parsingCompleted = !sourceCode.Parser.ParseFile(sourceCode, this.data.PassNumber, ref parsedDocument);
            }
            catch (Exception)
            {
                string details = string.Format(
                    CultureInfo.CurrentCulture,
                    "Exception thrown by parser '{0}' while processing '{1}'.",
                    sourceCode.Parser.Name,
                    sourceCode.Path);
                this.data.Core.SignalOutput(MessageImportance.High, details);
                throw;
            }

            if (parsingCompleted)
            {
                if (parsedDocument == null)
                {
                    string format = string.Format(CultureInfo.CurrentCulture, "Skipping: {0} - {1}", sourceCode.Project.Location.SubstringAfterLast('\\'), GetRelativeFileName(sourceCode));
                    this.data.Core.SignalOutput(MessageImportance.Normal, format);

                    documentStatus.Complete = true;
                }
                else if (this.TestAndRunAnalyzers(parsedDocument, sourceCode.Parser, analyzers, this.data.PassNumber))
                {
                    // Analysis of this document is completed.
                    documentStatus.Complete = true;

                    // Save the cache for this document and dispose it.
                    if (this.data.ResultsCache != null && sourceCode.Project.WriteCache)
                    {
                        this.data.ResultsCache.SaveDocumentResults(parsedDocument, sourceCode.Parser, sourceCode.Settings.WriteTime);
                    }

                    parsedDocument.Dispose();
                    parsedDocument = null;
                }
            }

            if (!documentStatus.Complete)
            {
                // Analysis of this document is not complete, so we will need to
                // perform another round of analysis after this one is finished.
                this.complete = false;

                // Cache the document if there is one.
                if (parsedDocument != null)
                {
                    documentStatus.Document = parsedDocument;
                }
            }

            StyleCopTrace.Out();
        }