internal static MetricsReport Of(IEnumerable<MetricsReport> reports) { var combinedReport = new MetricsReport(); foreach (var typeMetrics in reports.SelectMany(r => r.typeReports.Values)) combinedReport.AddTypeReport(typeMetrics); return combinedReport; }
protected void OutputAnalysisMetrics(string heading, MetricsReport metrics) { var prepared = new PreparedMetricsFactory().Prepare(metrics); Console.WriteLine(string.Format("{0} ({1} RLOC):\tACD: {2};\tCS: {3};\tCC: {4};\tML: {5};\tPF: {6};\tCN: {7};", heading, prepared.CommonKnowledge.RelevantLinesOfCode, prepared.Rated.AverageComponentDependency, prepared.Rated.AverageRatedClassSize, prepared.Rated.AverageRatedCyclomaticComplexity, prepared.Rated.AverageRatedMethodLength, prepared.Rated.AverageRatedNumberOfNonStaticPublicFields, prepared.Rated.NamespacesWithCyclicDependencies)); Console.WriteLine(string.Format("Hotspots:\tACD: {0};\tCS: {1};\tCC: {2};\tML: {3};\tPF: {4};\tCN: {5};", prepared.CumulativeComponentDependencyHotspots.Count(), prepared.ClassSizeHotspots.Count(), prepared.CyclomaticComplexityHotspots.Count(), prepared.MethodLengthHotspots.Count(), prepared.NumberOfNonStaticPublicFieldsHotspots.Count(), prepared.NumberOfNamespacesInCycleHotspots.Count())); Console.WriteLine(string.Format("Distributions:\tACD: {0};\tCS: {1};\tCC: {2};\tML: {3};\tPF: {4};\tCN: {5};", prepared.CumulativeComponentDependencyHistogram.GeometricalFit.Parameter, prepared.ClassSizeHistogram.GeometricalFit.Parameter, prepared.CyclomaticComplexityHistogram.GeometricalFit.Parameter, prepared.MethodLengthHistogram.GeometricalFit.Parameter, prepared.NumberOfNonStaticPublicFieldsHistogram.GeometricalFit.Parameter, prepared.NumberOfNamespacesInCycleHistogram.GeometricalFit.Parameter)); }
public IEnumerable<MethodMetricsReport> ComparedTo(MetricsReport metrics) { if (metrics != null) return AllChangedMethods(metrics); else return Enumerable.Empty<MethodMetricsReport>(); }
private static void AddTypesOf(MetricsReport[] reports, MetricsReport combinedReport) { foreach (var typeMetrics in reports.SelectMany(r => r.typeReports.Values)) { combinedReport.AddTypeReport(typeMetrics); } }
public static MutableGraph<NamespaceMetricsWithTypeMetrics> WithNamespacesOf(MetricsReport metrics) { var namespaceGraph = metrics.GraphOfTypes.Cast(t => t.AsNamespaceWithTypes(), n => n.HasName); foreach (var namespaceGroup in namespaceGraph.Vertices.GroupBy(n => n.Namespace.Name)) namespaceGraph.Reduce(namespaceGroup.AsNamespaceWithTypes(), namespaceGroup); return namespaceGraph; }
public static PropertyMetricsReport ForProperty(this MetricsReport metrics, PropertyInfo property) { return(new PropertyMetricsReport { Getter = metrics.ForMethod(property.GetFullGetterName()), Setter = metrics.ForMethod(property.GetFullSetterName()) }); }
internal static MetricsReport Of(params MetricsReport[] reports) { var combinedReport = new MetricsReport(); combinedReport.Remember.WhenCreated = reports.FirstCreated(); AddTypesOf(reports, combinedReport); combinedReport.CommonKnowledge.SetAssemblies(reports.Length); return combinedReport; }
private IEnumerable<MethodMetricsReport> AllChangedMethods(MetricsReport metrics) { return from m1 in _metrics.Methods join m2 in metrics.Methods on m1.Signature equals m2.Signature where !m1.CompilerGenerated where MethodsDiffer(m1, m2) select m1; }
internal static MetricsReport Of(params MetricsReport[] reports) { var combinedReport = new MetricsReport(); combinedReport.Remember.WhenCreated = reports.FirstCreated(); AddTypesOf(reports, combinedReport); combinedReport.CommonKnowledge.SetAssemblies(reports.Length); return(combinedReport); }
private void InitializeStatistics(MetricsReport metrics) { AverageRatedCyclomaticComplexity = RatedMethods.AverageAny(m => m.RatedCyclomaticComplexity, m => m.CyclomaticComplexity > 0); AverageRatedMethodLength = RatedMethods.AverageAny(m => m.RatedMethodLength, m => m.MethodLength > 0); AverageRatedClassSize = RatedTypes.AverageAny(m => m.RatedClassSize); AverageRatedNumberOfNonStaticPublicFields = RatedTypes.AverageAny(m => m.RatedNumberOfNonStaticPublicFields); AverageComponentDependency = RatedTypes.AverageAny(m => m.CumulativeComponentDependency) / metrics.CommonKnowledge.NumberOfClasses; NamespacesWithCyclicDependencies = (double)RatedNamespaces.CountAny(m => m.IsInCycle) / metrics.CommonKnowledge.NumberOfNamespaces; }
private IEnumerable <MethodMetricsReport> AllChangedMethods(MetricsReport metrics) { return(from m1 in _metrics.Methods join m2 in metrics.Methods on m1.Signature equals m2.Signature where !m1.CompilerGenerated where MethodsDiffer(m1, m2) select m1); }
public IEnumerable <MethodMetricsReport> ComparedTo(MetricsReport metrics) { if (metrics != null) { return(AllChangedMethods(metrics)); } else { return(Enumerable.Empty <MethodMetricsReport>()); } }
protected void OutputAnalysisTimes(string heading, MetricsReport metrics) { var times = new AnalyzeTimes(metrics); Console.WriteLine(string.Format("{0} ({1} RLOC, {2} assemblies):\t{3}s\t(analysis: {4}s\tpostprocessing: {5}s)", heading, metrics.CommonKnowledge.RelevantLinesOfCode, metrics.CommonKnowledge.NumberOfAssemblies, times.CompleteTime.TotalSeconds, times.AnalysisTime.TotalSeconds, times.PostProcessingTime.TotalSeconds)); }
private void OutputMetricsReport(MetricsReport metrics) { foreach (var namespaceMetrics in metrics.Namespaces) OutputNamespaceMetricsReport(namespaceMetrics); OutputSeperator(2); foreach (var type in metrics.Types.Where(t => !t.CompilerGenerated)) OutputTypeMetricsReport(type); OutputSeperator(2); foreach (var method in metrics.Methods.Where(m => !m.CompilerGenerated && !m.OnlyDeclaration)) OutputMethodMetricsReport(method); OutputSeperator(3); OutputRatings(metrics.Rate()); OutputHotspots(metrics.Hotspots()); }
internal RatedMetrics(MetricsReport metrics) { Metrics = metrics; InitializeRatedLists(metrics); InitializeStatistics(metrics); }
public PreparedMetricsReport(MetricsReport metrics) { Report = metrics; ThrowExceptionWhenNoMetrics(); Prepare(); }
public void Rloc_NoMethodNoTypes_0Lines() { var emptyMetrics = new MetricsReport(); Assert.AreEqual(0, emptyMetrics.CommonKnowledge.RelevantLinesOfCode); }
public static TypeMetricsReport ForType(this MetricsReport metrics, string typeName) { return(metrics.TypeForName(typeName)); }
public static Changes Of(MetricsReport metrics) { return new Changes(metrics); }
public static MethodMetricsReport ForMethod(this MetricsReport metrics, string memberName) { return((from m in metrics.Methods where m.Signature == memberName select m).FirstOrDefault()); }
public static MethodMetricsReport ForMethod(this MetricsReport metrics, Expression <Action> expression) { var methodName = (expression.Body as MethodCallExpression).GetCalleeName(); return(metrics.ForMethod(methodName)); }
public TypeReference(MetricsReport metrics, TypeMetricsReport source, TypeMetricsReport target) { this.metrics = metrics; this.Source = source; this.Target = target; }
public static TypeMetricsReport ForType <T>(this MetricsReport metrics) { return(metrics.ForType(typeof(T))); }
public static Changes Of(MetricsReport metrics) { return(new Changes(metrics)); }
public static PropertyMetricsReport ForProperty(this MetricsReport metrics, Expression <Func <object> > expression) { return(metrics.ForProperty(PropertyExtensions.GetPropertyInfo(expression))); }
private Changes(MetricsReport metrics) { _metrics = metrics; }
public static MutableGraph<TypeMetricsReport> WithTypesOf(MetricsReport metrics) { return metrics.Types .ToDictionary(t => t, t => t.InterestingDirectDependencies.Select(d => metrics.TypeForName(d))) .ToGraph(); }
private void InitializeRatedLists(MetricsReport metrics) { RatedMethods = metrics.Methods.ToList(m => m.Rate(), m => !m.CompilerGenerated && !m.OnlyDeclaration); RatedTypes = metrics.Types.ToList(m => m.Rate(), m => !m.CompilerGenerated); RatedNamespaces = metrics.Namespaces.ToList(m => m.Rate()); }
public static void Of(MetricsReport metrics) { metrics.SetInterestingDirectDependencies(); metrics.GraphOfTypes = CreateGraph.WithTypesOf(metrics); metrics.SetCumulativeComponentDependency(); }
public OutgoingTypeReferences(MetricsReport metrics, TypeMetricsReport source) { this.metrics = metrics; this.source = source; }
public static MethodMetricsReport ForMethod(this MetricsReport metrics, MethodInfo method) { return(metrics.ForMethod(method.GetFullName())); }
public void Analyze(string assemblyPath) { Report = new MetricsReport(); using (var host = new PeReader.DefaultHost()) TryToAnalyzeInHost(assemblyPath, host); }
private static void AddTypesOf(MetricsReport[] reports, MetricsReport combinedReport) { foreach (var typeMetrics in reports.SelectMany(r => r.typeReports.Values)) combinedReport.AddTypeReport(typeMetrics); }
internal MetricsHotspots(MetricsReport metrics) { Metrics = metrics; }
public static TypeMetricsReport ForTypeOf(this MetricsReport metrics, MethodMetricsReport methodMetrics) { return(metrics.TypeOf(methodMetrics)); }
public HotspotCyclomaticComplexity(MethodMetricsReport method, MetricsReport metrics) : base(method) { mMetrics = metrics; }
public HotspotNamespaceInCycle(NamespaceMetricsReport namespaceReport, MetricsReport metrics) : base(namespaceReport, metrics) { }
public NamespaceCycle(MetricsReport metrics, IEnumerable<NamespaceMetricsReport> namespaces) { this.metrics = metrics; this.namespaces = namespaces; Jump += type => { }; }
public void Ensure_MetricsReportIsAvailable() { if (Metrics == null) Metrics = Analyze.Me(); }
protected override void AnalyzeTypes(IAssembly assembly, PdbReader pdb, IMetadataHost host, MetricsReport report) { foreach (var typeMetrics in AnalyzeTypes(assembly, pdb, host)) report.AddTypeReport(typeMetrics); }
public HotspotCumulativeComponentDependency(TypeMetricsReport type, MetricsReport metrics) : base(type, metrics) { }
public static IEnumerable <TypeMetricsReport> TypesOfNamespace(this MetricsReport metrics, NamespaceMetricsReport namespaceMetrics) { return(metrics.TypesOf(namespaceMetrics)); }
public static IEnumerable <MethodMetricsReport> MethodsOfType(this MetricsReport metrics, TypeMetricsReport typeMetrics) { return(metrics.MethodsOf(typeMetrics)); }
public HotspotClassSize(TypeMetricsReport type, MetricsReport metrics) : base(type, metrics) { }
protected abstract void AnalyzeTypes(IAssembly assembly, PdbReader pdb, IMetadataHost host, MetricsReport report);
public static TypeMetricsReport ForType(this MetricsReport metrics, Type type) { return(metrics.ForType(type.GetFullName())); }