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());
}
