Code Metrics

RetailCoder.VBE/Extension.cs

@@ -221,7 +221,9 @@ private void Startup()
             catch (Exception e)
             {
                 _logger.Log(LogLevel.Fatal, e, "Startup sequence threw an unexpected exception.");
-                //throw; // <<~ uncomment to crash the process
+#if DEBUG
+                throw; // <<~ uncomment to crash the process
+#endif
             }
         }
 

RetailCoder.VBE/Navigation/CodeMetrics/CodeMetricsAnalyst.cs

@@ -0,0 +1,194 @@
+using System.Collections.Generic;
+using System.Linq;
+using Rubberduck.Parsing.VBA;
+using Antlr4.Runtime.Tree;
+using Rubberduck.Parsing.Grammar;
+using Rubberduck.VBEditor;
+using Antlr4.Runtime.Misc;
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.SmartIndenter;
+
+namespace Rubberduck.Navigation.CodeMetrics
+{
+    public class CodeMetricsAnalyst : ICodeMetricsAnalyst
+    {
+        private readonly IIndenterSettings indenterSettings;
+
+        public CodeMetricsAnalyst(IIndenterSettings indenterSettings)
+        {
+            this.indenterSettings = indenterSettings;
+        }
+
+        public IEnumerable<ModuleMetricsResult> ModuleMetrics(RubberduckParserState state)
+        {
+            if (state == null || !state.AllUserDeclarations.Any())
+            {
+                // must not return Enumerable.Empty
+                yield break;
+            }
+
+            var trees = state.ParseTrees;
+            var results = new List<CodeMetricsResult>();
+
+            foreach (var moduleTree in trees)
+            {
+                yield return GetModuleResult(moduleTree.Key, moduleTree.Value, state.DeclarationFinder);
+            };
+        }
+
+        public ModuleMetricsResult GetModuleResult(RubberduckParserState state, QualifiedModuleName qmn)
+        {
+            return GetModuleResult(qmn, state.GetParseTree(qmn), state.DeclarationFinder);
+        }
+
+        private ModuleMetricsResult GetModuleResult(QualifiedModuleName qmn, IParseTree moduleTree, DeclarationFinder declarationFinder)
+        {
+            // Consider rewrite as visitor? That should make subtrees easier and allow us to expand metrics
+            var cmListener = new CodeMetricsListener(declarationFinder, indenterSettings);
+            ParseTreeWalker.Default.Walk(cmListener, moduleTree);
+            return cmListener.GetMetricsResult(qmn);
+        }
+
+
+        private class CodeMetricsListener : VBAParserBaseListener
+        {
+            private readonly DeclarationFinder _finder;
+            private readonly IIndenterSettings _indenterSettings;
+
+            private Declaration currentMember;
+            private List<CodeMetricsResult> results = new List<CodeMetricsResult>();
+            private List<CodeMetricsResult> moduleResults = new List<CodeMetricsResult>();
+
+            private List<MemberMetricsResult> memberResults = new List<MemberMetricsResult>();
+
+            public CodeMetricsListener(DeclarationFinder finder, IIndenterSettings indenterSettings)
+            {
+                _finder = finder;
+                _indenterSettings = indenterSettings;
+            }
+
+            public override void EnterEndOfLine([NotNull] VBAParser.EndOfLineContext context)
+            {
+                int followingIndentationLevel = 0;
+                // we have a proper newline
+                if (context.NEWLINE() != null)
+                {
+                    // the last whitespace, which is the one in front of the next line's contents
+                    var followingWhitespace = context.whiteSpace().LastOrDefault();
+                    followingIndentationLevel = IndentationLevelFromWhitespace(followingWhitespace);
+                }
+                (currentMember == null ? moduleResults : results).Add(new CodeMetricsResult(1, 0, followingIndentationLevel));
+            }
+
+            public override void EnterIfStmt([NotNull] VBAParser.IfStmtContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+            }
+
+            public override void EnterElseIfBlock([NotNull] VBAParser.ElseIfBlockContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+            }
+
+            // notably: NO additional complexity for an Else-Block
+
+            public override void EnterForEachStmt([NotNull] VBAParser.ForEachStmtContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+            }
+
+            public override void EnterForNextStmt([NotNull] VBAParser.ForNextStmtContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+            }
+
+            public override void EnterCaseClause([NotNull] VBAParser.CaseClauseContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+            }
+
+            public override void EnterSubStmt([NotNull] VBAParser.SubStmtContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+                currentMember = _finder.DeclarationsWithType(DeclarationType.Procedure).Where(d => d.Context == context).First();
+            }
+
+            public override void ExitSubStmt([NotNull] VBAParser.SubStmtContext context)
+            {
+                ExitMeasurableMember();
+            }
+
+            public override void EnterFunctionStmt([NotNull] VBAParser.FunctionStmtContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+                currentMember = _finder.DeclarationsWithType(DeclarationType.Function).Where(d => d.Context == context).First();
+            }
+
+            public override void ExitFunctionStmt([NotNull] VBAParser.FunctionStmtContext context)
+            {
+                ExitMeasurableMember();
+            }
+
+            public override void EnterPropertyGetStmt([NotNull] VBAParser.PropertyGetStmtContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+                currentMember = _finder.DeclarationsWithType(DeclarationType.PropertyGet).Where(d => d.Context == context).First();
+            }
+
+            public override void ExitPropertyGetStmt([NotNull] VBAParser.PropertyGetStmtContext context)
+            {
+                ExitMeasurableMember();
+            }
+
+            public override void EnterPropertyLetStmt([NotNull] VBAParser.PropertyLetStmtContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+                currentMember = _finder.DeclarationsWithType(DeclarationType.PropertyLet).Where(d => d.Context == context).First();
+            }
+
+            public override void ExitPropertyLetStmt([NotNull] VBAParser.PropertyLetStmtContext context)
+            {
+                ExitMeasurableMember();
+            }
+
+            public override void EnterPropertySetStmt([NotNull] VBAParser.PropertySetStmtContext context)
+            {
+                results.Add(new CodeMetricsResult(0, 1, 0));
+                currentMember = _finder.DeclarationsWithType(DeclarationType.PropertySet).Where(d => d.Context == context).First();
+            }
+
+            public override void ExitPropertySetStmt([NotNull] VBAParser.PropertySetStmtContext context)
+            { 
+                ExitMeasurableMember();
+            }
+
+            public override void EnterBlockStmt([NotNull] VBAParser.BlockStmtContext context)
+            {
+                // there is a whitespace context here after the option of a statementLabel.
+                // we need to account for that
+                results.Add(new CodeMetricsResult(0, 0, IndentationLevelFromWhitespace(context.whiteSpace())));
+            }
+
+            private int IndentationLevelFromWhitespace(VBAParser.WhiteSpaceContext wsContext)
+            {
+                if (wsContext == null) return 0;
+                // the only thing that contains underscores is the line-continuation at this point
+                var lineContinuation = wsContext.children.LastOrDefault((tree) => tree.GetText().Contains("_"));
+                var index = lineContinuation != null ? wsContext.children.IndexOf(lineContinuation) : 0;
+                return (wsContext?.ChildCount ?? 0 - index) / _indenterSettings.IndentSpaces;
+            }
+
+            private void ExitMeasurableMember()
+            {
+                memberResults.Add(new MemberMetricsResult(currentMember, results));
+                results = new List<CodeMetricsResult>(); // reinitialize to drop results
+                currentMember = null;
+            }
+
+            internal ModuleMetricsResult GetMetricsResult(QualifiedModuleName qmn)
+            {
+                return new ModuleMetricsResult(qmn, memberResults, moduleResults);
+            }
+        }
+    }
+}

RetailCoder.VBE/Navigation/CodeMetrics/CodeMetricsResult.cs

@@ -0,0 +1,56 @@
+using Rubberduck.Parsing.Symbols;
+using Rubberduck.VBEditor;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.Navigation.CodeMetrics
+{
+    public struct CodeMetricsResult
+    {
+        public CodeMetricsResult(int lines, int cyclomaticComplexity, int nesting)
+            : this(lines, cyclomaticComplexity, nesting, Enumerable.Empty<CodeMetricsResult>())
+        { 
+        }
+
+        public CodeMetricsResult(int lines, int cyclomaticComplexity, int nesting, IEnumerable<CodeMetricsResult> childScopeResults)
+        {
+            var childScopeMetric =
+                childScopeResults.Aggregate(new CodeMetricsResult(), (r1, r2) => new CodeMetricsResult(r1.Lines + r2.Lines, r1.CyclomaticComplexity + r2.CyclomaticComplexity, Math.Max(r1.MaximumNesting, r2.MaximumNesting)));
+            Lines = lines + childScopeMetric.Lines;
+            CyclomaticComplexity = cyclomaticComplexity + childScopeMetric.CyclomaticComplexity;
+            MaximumNesting = Math.Max(nesting, childScopeMetric.MaximumNesting);
+        }
+
+        public int Lines { get; private set; }
+        public int CyclomaticComplexity { get; private set; }
+        public int MaximumNesting { get; private set; }
+
+    }
+
+    public struct MemberMetricsResult
+    {
+        public Declaration Member { get; private set; }
+        public CodeMetricsResult Result { get; private set; }
+
+        public MemberMetricsResult(Declaration member, IEnumerable<CodeMetricsResult> contextResults)
+        {
+            Member = member;
+            Result = new CodeMetricsResult(0, 0, 0, contextResults);
+        }
+    }
+
+    public struct ModuleMetricsResult
+    {
+        public QualifiedModuleName ModuleName { get; private set; }
+        public CodeMetricsResult Result { get; private set; }
+        public IReadOnlyDictionary<Declaration, CodeMetricsResult> MemberResults { get; private set; }
+
+        public ModuleMetricsResult(QualifiedModuleName moduleName, IEnumerable<MemberMetricsResult> memberMetricsResult, IEnumerable<CodeMetricsResult> nonMemberResults)
+        {
+            ModuleName = moduleName;
+            MemberResults = memberMetricsResult.ToDictionary(mmr => mmr.Member, mmr => mmr.Result);
+            Result = new CodeMetricsResult(0, 0, 0, nonMemberResults.Concat(MemberResults.Values));
+        }
+    }
+}

RetailCoder.VBE/Navigation/CodeMetrics/CodeMetricsViewModel.cs

@@ -0,0 +1,72 @@
+using NLog;
+using Rubberduck.Parsing.VBA;
+using Rubberduck.UI;
+using Rubberduck.UI.Command;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Rubberduck.Navigation.CodeMetrics
+{
+    public class CodeMetricsViewModel : ViewModelBase
+    {
+        private readonly RubberduckParserState _state;
+
+        public CodeMetricsViewModel(RubberduckParserState state, ICodeMetricsAnalyst analyst)
+
+        {
+            _state = state;
+            // FIXME deregister event on destruction
+            _state.StateChanged += (_, change) =>
+            {
+                if (change.State == ParserState.Ready)
+                {
+                    ModuleMetrics = analyst.ModuleMetrics(_state);
+                }
+            };
+        }
+
+        public void FilterByName(object projects, string text)
+        {
+            throw new NotImplementedException();
+        }
+
+        private IEnumerable<ModuleMetricsResult> _moduleMetrics;
+        public IEnumerable<ModuleMetricsResult> ModuleMetrics {
+            get => _moduleMetrics;
+            private set
+            {
+                _moduleMetrics = value;
+                OnPropertyChanged();
+            }
+        }
+
+
+        //public CommandBase RefreshCommand { get; set; }
+
+
+        private bool _canSearch;
+        public bool CanSearch
+        {
+            get => _canSearch;
+            set
+            {
+                _canSearch = value;
+                OnPropertyChanged();
+            }
+        }
+
+        private bool _isBusy;
+        public bool IsBusy
+        {
+            get => _isBusy;
+            set
+            {
+                _isBusy = value;
+                OnPropertyChanged();
+                // If the window is "busy" then hide the Refresh message
+                OnPropertyChanged("EmptyUIRefreshMessageVisibility");
+            }
+        }
+    }
+}

RetailCoder.VBE/Navigation/CodeMetrics/ICodeMetricsAnalyst.cs

@@ -0,0 +1,15 @@
+using Rubberduck.Parsing.VBA;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Rubberduck.Navigation.CodeMetrics
+{
+    public interface ICodeMetricsAnalyst
+    {
+        IEnumerable<ModuleMetricsResult> ModuleMetrics(RubberduckParserState state);
+    }
+}

RetailCoder.VBE/Root/RubberduckIoCInstaller.cs

@@ -43,6 +43,8 @@
 using Rubberduck.VBEditor.SafeComWrappers.Abstract;
 using Rubberduck.VBEditor.SafeComWrappers.Office.Core.Abstract;
 using Component = Castle.MicroKernel.Registration.Component;
+using Rubberduck.UI.CodeMetrics;
+using Rubberduck.Navigation.CodeMetrics;
 
 namespace Rubberduck.Root
 {
@@ -463,6 +465,7 @@ private static Type[] NavigateMenuItems()
 #if DEBUG
                 typeof(RegexSearchReplaceCommandMenuItem),
 #endif
+
                 typeof(FindSymbolCommandMenuItem),
                 typeof(FindAllReferencesCommandMenuItem),
                 typeof(FindAllImplementationsCommandMenuItem)
@@ -486,6 +489,7 @@ private Type[] ToolsMenuItems()
             {
                 typeof(RegexAssistantCommandMenuItem),
                 typeof(ToDoExplorerCommandMenuItem),
+                typeof(CodeMetricsCommandMenuItem),
                 typeof(ExportAllCommandMenuItem)
             };
 
@@ -598,6 +602,12 @@ private void RegisterCommandsWithPresenters(IWindsorContainer container)
                 .LifestyleTransient()
                 .Named(typeof(CodeExplorerCommand).Name));
 
+            container.Register(Component.For<CommandBase>()
+                .ImplementedBy<CodeMetricsCommand>()
+                .DependsOn(Dependency.OnComponent<IDockablePresenter, CodeMetricsDockablePresenter>())
+                .LifestyleSingleton()
+                .Named(typeof(CodeMetricsCommand).Name));
+
             container.Register(Component.For<CommandBase>()
                 .ImplementedBy<ToDoExplorerCommand>()
                 .DependsOn(Dependency.OnComponent<IDockablePresenter, ToDoExplorerDockablePresenter>())