private void SetCommonKnowledge(PreparedMetricsReport metrics) { sqiParameters.Classes = metrics.CommonKnowledge.NumberOfTypes; sqiParameters.Methods = metrics.CommonKnowledge.NumberOfMethods; sqiParameters.Namespaces = metrics.CommonKnowledge.NumberOfNamespaces; sqiParameters.Rloc = metrics.CommonKnowledge.RelevantLinesOfCode; }
protected override void AnalysisFinished(PreparedMetricsReport metrics) { SetCommonKnowledge(metrics); SetReportParameters(metrics); SetDetailParameters(); AddToSqiHistory(); }
private void SetFooter(PreparedMetricsReport metrics) { Rloc = string.Format("{0} Relevant Lines Of Code", metrics.CommonKnowledge.RelevantLinesOfCode); Changed(() => Rloc); LastMetricsTime = string.Format(" ({0})", DateTime.Now.ToShortTimeString()); Changed(() => LastMetricsTime); }
private void SetReportParameters(PreparedMetricsReport metrics) { _NamespacesInCycles.Value = SqiParameterType.Number(metrics.NumberOfNamespacesInCycleHotspots.Count()); _ComplicatedMethods.Value = SqiParameterType.Number(metrics.Hotspots.OfCyclomaticComplexityOver(5).Count()); _AverageComponentDependency.Value = SqiParameterType.Percentage(metrics.Rated.AverageComponentDependency); _BigClasses.Value = SqiParameterType.Number(metrics.Hotspots.OfClassSizeOver(20).Count()); _BigMethods.Value = SqiParameterType.Number(metrics.Hotspots.OfMethodLengthOver(15).Count()); }
private void SetCyclomaticComplexity(PreparedMetricsReport metrics) { _CyclomaticComplexity.Update( metrics.Rated.AverageRatedCyclomaticComplexity, metrics.CommonKnowledge.NumberOfMethods, metrics.CyclomaticComplexityHotspots.Count(), metrics.CyclomaticComplexityHistogram.GeometricalFit.Parameter); }
protected override void AnalysisFinished(PreparedMetricsReport metrics) { NamespacesGraph = NamespaceGraph(metrics); Changed(() => NamespacesGraph); TypesGraph = TypeGraph(metrics); Changed(() => TypesGraph); }
private void SetACD(PreparedMetricsReport metrics) { _AverageComponentDependency.Update( metrics.Rated.AverageComponentDependency, metrics.CommonKnowledge.NumberOfTypes, metrics.CumulativeComponentDependencyHotspots.Count(), metrics.CumulativeComponentDependencyHistogram.GeometricalFit.Parameter); }
private ViewHub() { metricsFactory = new PreparedMetricsFactory(); AnalysisStarted += () => analysisReady = false; MetricsReady += m => analysisReady = true; MetricsReady += m => MostRecentMetrics = m; ShouldUseParallelism = () => false; }
private void SetNamespacesWithCycles(PreparedMetricsReport metrics) { _NamespacesWithCycles.Update( metrics.Rated.NamespacesWithCyclicDependencies, metrics.CommonKnowledge.NumberOfNamespaces, metrics.NumberOfNamespacesInCycleHotspots.Count(), metrics.NumberOfNamespacesInCycleHistogram.GeometricalFit.Parameter); }
private void SetNumberOfNonStaticPublicFields(PreparedMetricsReport metrics) { _NonStaticPublicFields.Update( metrics.Rated.AverageRatedNumberOfNonStaticPublicFields, metrics.CommonKnowledge.NumberOfTypes, metrics.NumberOfNonStaticPublicFieldsHotspots.Count(), metrics.NumberOfNonStaticPublicFieldsHistogram.GeometricalFit.Parameter); }
private void SetMethodLength(PreparedMetricsReport metrics) { _MethodLength.Update( metrics.Rated.AverageRatedMethodLength, metrics.CommonKnowledge.NumberOfMethods, metrics.MethodLengthHotspots.Count(), metrics.MethodLengthHistogram.GeometricalFit.Parameter); }
private static BidirectionalGraph <object, IEdge <object> > TypeGraph(PreparedMetricsReport metrics) { var graph = new BidirectionalGraph <object, IEdge <object> >(false); graph.AddVertexRange(metrics.Report.TypeGraph.Vertices.Select(v => v.FullName)); graph.AddEdgeRange(metrics.Report.TypeGraph.Edges.Select(e => new Edge <object>(e.Item1.FullName, e.Item2.FullName))); return(graph); }
protected override void AnalysisFinished(PreparedMetricsReport metrics) { var graph = GetTypeGraph(metrics); var cycles = graph.Cycles(); var cycleVMs = GetViewModels(metrics, cycles); Display(cycleVMs); }
private void SetClassSize(PreparedMetricsReport metrics) { _ClassSize.Update( metrics.Rated.AverageRatedClassSize, metrics.CommonKnowledge.NumberOfTypes, metrics.ClassSizeHotspots.Count(), metrics.ClassSizeHistogram.GeometricalFit.Parameter); }
protected override void AnalysisFinished(PreparedMetricsReport metrics) { Dispatch(ClearLists); Dispatch(() => SetClassSizes(metrics.ClassSizeHotspots, metrics.Report)); Dispatch(() => SetCumulativeComponentDependencies(metrics.CumulativeComponentDependencyHotspots, metrics.Report)); Dispatch(() => SetCyclomaticComplexities(metrics.CyclomaticComplexityHotspots, metrics.Report)); Dispatch(() => SetMethodLengths(metrics.MethodLengthHotspots, metrics.Report)); Dispatch(() => SetNamespacesInCycle(metrics.NumberOfNamespacesInCycleHotspots, metrics.Report)); Dispatch(() => SetNonStaticPublicFields(metrics.NumberOfNonStaticPublicFieldsHotspots, metrics.Report)); }
private static IGraph <TypeMetricsReport> GetTypeGraph(PreparedMetricsReport metrics) { var graph = metrics.Report.TypeGraph.Clone(); var typesToIgnore = graph.Vertices.Where(t => t.CompilerGenerated).ToList(); foreach (var type in typesToIgnore) { graph.Ignore(type); } return(graph); }
protected override void AnalysisFinished(PreparedMetricsReport metrics) { Dispatch(ClearLists); ClassSizesText = Fit(HistogramOf(ClassSizes, metrics.ClassSizeHistogram)); CumulativeComponentDependenciesText = Fit(HistogramOf(CumulativeComponentDependencies, metrics.CumulativeComponentDependencyHistogram)); CyclomaticComplexitiesText = Fit(HistogramOf(CyclomaticComplexities, metrics.CyclomaticComplexityHistogram)); MethodLengthsText = Fit(HistogramOf(MethodLengths, metrics.MethodLengthHistogram)); NamespacesInCycleText = Fit(HistogramOf(NamespacesInCycle, metrics.NumberOfNamespacesInCycleHistogram)); NonStaticPublicFieldsText = Fit(HistogramOf(NonStaticPublicFields, metrics.NumberOfNonStaticPublicFieldsHistogram)); ChangeAllTexts(); }
private void OnAnalysisFinished(PreparedMetricsReport m) { if (m != null) { AnalysisFinished(m); } Dispatch(() => { AnalysisRunning = false; Changed(() => AnalysisRunning); }); }
protected override void AnalysisFinished(PreparedMetricsReport metrics) { ChangedMethods = metrics.ChangedMethods; Dispatch(() => { SetACD(metrics); SetClassSize(metrics); SetCyclomaticComplexity(metrics); SetMethodLength(metrics); SetNumberOfNonStaticPublicFields(metrics); SetNamespacesWithCycles(metrics); SetFooter(metrics); }); }
private static IEnumerable <TypeCycle> GetViewModels(PreparedMetricsReport metrics, StronglyConntectedComponents <TypeMetricsReport> cycles) { return(from cycle in cycles.All where cycle.VertexCount > 1 orderby cycle.VertexCount descending select new TypeCycle { DisplayName = string.Format("{0} classes", cycle.VertexCount), TypesInCycle = from type in cycle.Vertices select new Type { DisplayName = type.FullName, ReferencedTypes = from referencedType in type.InterestingDirectDependencies.Intersect(cycles.OfVertex(type).Vertices.Select(t => t.FullName)) where type.FullName != referencedType select new TypeReferenceVM(metrics, type, referencedType) } }); }
protected override void AnalysisFinished(PreparedMetricsReport metrics) { this.metrics = metrics; FillTypeCollection(); }
protected abstract void AnalysisFinished(PreparedMetricsReport metrics);
protected override void AnalysisFinished(PreparedMetricsReport metrics) { base.AnalysisFinished(metrics); Dispatch(() => SetCumulativeComponentDependenciesText(metrics.CommonKnowledge)); }
public TypeReferenceVM(PreparedMetricsReport metrics, TypeMetricsReport source, string target) : this(new TypeReference(metrics.Report, source, metrics.Report.ForType(target))) { }
public PreparedMetricsReport Prepare(MetricsReport metrics) { var preparedMetrics = new PreparedMetricsReport(metrics, _lastMetrics); _lastMetrics = metrics; return preparedMetrics; }