internal void UpdateFor(TypeMetricsReport type) { if (!type.CompilerGenerated) { NumberOfClasses++; RelevantLinesOfCode += 2; } }
internal void UpdateFor(TypeMetricsReport type) { if (!type.CompilerGenerated) { NumberOfTypes++; RelevantLinesOfCode += 2 + type.NumberOfFields; } }
internal RatedTypeMetrics(TypeMetricsReport metrics) { Name = metrics.Name; FullName = metrics.FullName; CumulativeComponentDependency = metrics.CumulativeComponentDependency; RatedClassSize = metrics.RateClassSize(); RatedNumberOfNonStaticPublicFields = metrics.RateNumberOfNonStaticPublicFields(); }
public static double NumberOfNonStaticPublicFields(int nspfs) { var metrics = new TypeMetricsReport { NumberOfNonStaticPublicFields = nspfs }; metrics.CommonKnowledge = new CommonReportKnowledge(0, 1, 0, 0); return(metrics.Rate().RatedNumberOfNonStaticPublicFields); }
public static double ClassSize(int cs) { var metrics = new TypeMetricsReport { NumberOfMethods = cs }; metrics.CommonKnowledge = new CommonReportKnowledge(0, 1, 0, 0); return(metrics.Rate().RatedClassSize); }
private static NamespaceMetricsWithTypeMetrics AsNamespaceWithTypes(this TypeMetricsReport t) { var namespaceWithTypes = new NamespaceMetricsWithTypeMetrics(); namespaceWithTypes.Namespace = new NamespaceMetricsReport { Name = t.Namespaces.FirstOrDefault() }; namespaceWithTypes.AddTypeReport(t); return(namespaceWithTypes); }
private static TypeMetricsWithMethodMetrics TypeMetrics(TypeMetricsReport typeMetrics, IEnumerable <MethodMetricsReport> methodMetrics) { var typeWithMethods = new TypeMetricsWithMethodMetrics() { Type = typeMetrics }; typeWithMethods.AddMethodReports(methodMetrics); return(typeWithMethods); }
internal static double RateNumberOfNonStaticPublicFields(this TypeMetricsReport metrics) { if (metrics.NumberOfNonStaticPublicFields > Limits.NumberOfNonStaticPublicFields(metrics.CommonKnowledge)) { return(1.0); } else { return(0.0); } }
internal static double RateClassSize(this TypeMetricsReport metrics) { if (metrics.ClassSize > Limits.ClassSize(metrics.CommonKnowledge)) { return(((1.0 / Limits.ClassSize(metrics.CommonKnowledge)) * metrics.ClassSize) - 1); } else { return(0.0); } }
private void OutputTypeMetricsReport(TypeMetricsReport typeMetrics) { OutputSeperator(); Output(String.Format("Name:\t\t{0}", typeMetrics.Name)); Output(String.Format("Fullname:\t{0}", typeMetrics.FullName)); Output(String.Format("Generated:\t{0}", typeMetrics.CompilerGenerated)); Output(String.Format("\tNumberOfNonStaticPublicFields:\t{0}", typeMetrics.NumberOfNonStaticPublicFields)); Output(String.Format("\tClassSize:\t\t\t{0}", typeMetrics.ClassSize)); Output(String.Format("\tCumulativeComponentDependency:\t{0}", typeMetrics.CumulativeComponentDependency)); Output(String.Format("\tInterestingDependencies:\t{0}", string.Join(", ", typeMetrics.InterestingDirectDependencies))); Output(); }
private IEnumerable <TypeMetricsReport> DependenciesOf(TypeMetricsReport type) { return(from reference in type.InterestingDirectDependencies select metrics.ForType(reference)); }
public OutgoingTypeReferences(MetricsReport metrics, TypeMetricsReport source) { this.metrics = metrics; this.source = source; }
public override bool Verify(TypeMetricsReport metrics) { return(metrics.DirectDependencies.Contains(ExpectedDependency)); }
public override bool Verify(TypeMetricsReport metrics) { return(!metrics.InterestingDirectDependencies.Contains(ExpectedNoInterestingDependency)); }
public static int Of(TypeMetricsReport type, MutableGraph <TypeMetricsReport> graph) { return(type.GetDirectAndIndirectDependencies(graph) .Count(t => !t.CompilerGenerated)); }
public TypeJump(MetricsReport metrics, TypeMetricsReport type, IJumpToSource jumper) { this.metrics = metrics; this.type = type; this.jumper = jumper; }
public HotspotCumulativeComponentDependency(TypeMetricsReport type, MetricsReport metrics) : base(type, metrics) { }
public HotspotClassSize(TypeMetricsReport type, MetricsReport metrics) : base(type, metrics) { }
public static RatedTypeMetrics Rate(this TypeMetricsReport metrics) { return(new RatedTypeMetrics(metrics)); }
public override bool Verify(TypeMetricsReport metrics) { return(metrics.Namespaces.Contains(ExpectedNamespace)); }
private NamespaceMetricsReport NamespaceOf(TypeMetricsReport type) { return(metrics.ForNamespace(type.Namespaces.First())); }
public static void To(MetricsReport metrics, TypeMetricsReport type, IJumpToSource jumper) { new TypeJump(metrics, type, jumper).Jump(); }
public override bool Verify(TypeMetricsReport metrics) { return(metrics.NumberOfMethods == ExpectedNumberOfMethods); }
private static IEnumerable <TypeMetricsReport> GetDirectAndIndirectDependencies(this TypeMetricsReport type, MutableGraph <TypeMetricsReport> graph) { return(graph.Reach(type).Vertices); }
public override bool Verify(TypeMetricsReport metrics) { return(metrics.CumulativeComponentDependency == ExpectedCumulativeComponentDependency); }
internal MethodAndTypeMetrics(TypeMetricsReport type, MethodMetricsReport method) { this.method = method; this.type = type; }
public HotspotNonStaticPublicFields(TypeMetricsReport type, MetricsReport metrics) : base(type, metrics) { }
public abstract bool Verify(TypeMetricsReport metrics);
public override bool Verify(TypeMetricsReport metrics) { return(metrics.NumberOfNonStaticPublicFields == ExpectedNumberOfNonStaticPublicFields); }
public TypeReferenceVM(PreparedMetricsReport metrics, TypeMetricsReport source, string target) : this(new TypeReference(metrics.Report, source, metrics.Report.ForType(target))) { }
public static IEnumerable <string> Of(TypeMetricsReport type, IEnumerable <TypeMetricsReport> otherTypes) { return(type.DirectDependencies .Intersect(otherTypes.Select(t => t.FullName)) .ToList()); }