private static Types GetTypesResult(TypeMetrics metrics)
{
Types type = new Types();
type.AddRange(MetricsReportBuilder.GetTypeResults(metrics));
return(type);
}
private static IEnumerable <VsCodeMetrics.Entities.Type> GetTypeResults(TypeMetrics metrics)
{
foreach (TypeMetric typeMetric in metrics.Results)
{
VsCodeMetrics.Entities.Type type = new VsCodeMetrics.Entities.Type();
type.Name = typeMetric.Name;
VsCodeMetrics.Entities.Type type1 = type;
if (typeMetric.Kind == TypeMetricKind.Class)
{
type1.Kind = "Class";
}
else if (typeMetric.Kind == TypeMetricKind.Interface)
{
type1.Kind = "Interface";
}
else if (typeMetric.Kind == TypeMetricKind.Struct)
{
type1.Kind = "Struct";
}
else if (typeMetric.Kind == TypeMetricKind.ValueType)
{
type1.Kind = "ValueType";
}
else if (typeMetric.Kind == TypeMetricKind.Delegate)
{
type1.Kind = "Delegate";
}
if (typeMetric.Metrics != null)
{
type1.Add(MetricsReportBuilder.GetMetricsResult(typeMetric.Metrics));
}
type1.Add(MetricsReportBuilder.GetMembersResult(typeMetric.MemberMetrics));
yield return(type1);
}
}
private TypeMetrics CalculateTypeMetrics(Compilation compilation, NamespaceDeclaration namespaceNodes)
{
List <TypeMetric> typeMetrics = new List <TypeMetric>();
foreach (KeyValuePair <string, TypeDeclaration> typeDeclaration in GetTypeDeclarations(namespaceNodes))
{
TypeDeclaration value = typeDeclaration.Value;
MemberMetrics memberMetric = CalculateMemberMetrics(compilation, value);
typeMetrics.Add(CalculateTypeMetrics(compilation, value, memberMetric));
}
TypeMetrics typeMetric = new TypeMetrics()
{
Results = typeMetrics.ToList <TypeMetric>().AsReadOnly()
};
return(typeMetric);
}
public NamespaceMetrics Calculate(Project project)
{
Compilation compilation = project.GetCompilation();
IEnumerable <KeyValuePair <string, NamespaceDeclaration> > namespaceDeclarations = GetNamespaceDeclarations(project, this.IgnoreGeneratedCode);
List <NamespaceMetric> namespaceMetrics = new List <NamespaceMetric>();
foreach (KeyValuePair <string, NamespaceDeclaration> namespaceDeclaration in namespaceDeclarations)
{
TypeMetrics typeMetric = CalculateTypeMetrics(compilation, namespaceDeclaration.Value);
NamespaceMetric namespaceMetric = CalculateNamespaceMetrics(compilation, namespaceDeclaration.Value, typeMetric);
namespaceMetrics.Add(namespaceMetric);
}
return(new NamespaceMetrics()
{
Results = namespaceMetrics.AsReadOnly()
});
}
public NamespaceMetric(
double maintainabilityIndex,
int cyclomaticComplexity,
int linesOfCode,
IEnumerable <ITypeCoupling> classCouplings,
int depthOfInheritance,
string name,
IEnumerable <ITypeMetric> typeMetrics,
IDocumentation documentation)
{
MaintainabilityIndex = maintainabilityIndex;
CyclomaticComplexity = cyclomaticComplexity;
LinesOfCode = linesOfCode;
ClassCouplings = classCouplings.AsArray();
DepthOfInheritance = depthOfInheritance;
Name = name;
Documentation = documentation;
TypeMetrics = typeMetrics.AsArray();
Abstractness = TypeMetrics.Count(x => x.IsAbstract) / (double)TypeMetrics.Count();
}
public NamespaceMetric CalculateFrom(NamespaceDeclarationSyntaxInfo namespaceNode, TypeMetrics typeMetrics)
{
NamespaceMetric namespaceMetric = new NamespaceMetric()
{
Name = namespaceNode.Name,
TypeMetrics = typeMetrics
};
foreach (MetricCalculator calculator in calculators)
{
namespaceMetric.AddMetricResult(calculator.Calculate <TypeMetrics, TypeMetric>(typeMetrics));
}
return(namespaceMetric);
}
private NamespaceMetric CalculateNamespaceMetrics(Compilation compilation, NamespaceDeclaration namespaceNodes, TypeMetrics typeMetrics)
{
if (!namespaceNodes.SyntaxNodes.Any <NamespaceDeclarationSyntaxInfo>())
{
return(null);
}
NamespaceDeclarationSyntaxInfo namespaceDeclarationSyntaxInfo = namespaceNodes.SyntaxNodes.FirstOrDefault <NamespaceDeclarationSyntaxInfo>();
SemanticModel semanticModel = compilation.GetSemanticModel(namespaceDeclarationSyntaxInfo.Syntax.SyntaxTree);
return((new NamespaceMetricsCalculator(semanticModel)).CalculateFrom(namespaceDeclarationSyntaxInfo, typeMetrics));
}
